Ledgenter vs AutoGen and AG2
AutoGen — Microsoft's framework, now in maintenance mode as the team's focus shifted to the Microsoft Agent Framework — and AG2, the community fork the original creators maintain after forking in late 2024, both coordinate multi-agent work the same way: a GroupChat (or AutoGen's newer event-driven Team) runs a set of agents that share one conversation, a manager or selector picks the next speaker each turn, and every agent sees the accumulated transcript as its working context. Short-term memory is that transcript; opt-in long-term memory (AG2's Teachability, or a memory protocol in AutoGen's newer API) stores facts a single agent learned in a vector store it can recall later. For a bounded conversation among a handful of agents in one process, that's a proven, well-documented shape.
It's still not a shared work-state. The conversation is the coordination mechanism — an agent 'picks up work' by being selected to speak next, not by an atomic claim, and two GroupChats running in parallel don't see each other's transcript unless you wire that yourself. A run can serialize its state to resume after a crash, but that's one run's transcript checkpointed, not a queryable record a second run or a different agent reads. And 'done' is a termination condition — a max-turns count, a keyword, a function returning true — not a dependency graph or a check on the work itself. Ledgenter is the layer underneath: durable, shared work-state — tasks, atomic claims, decisions, knowledge, handoffs — any AutoGen or AG2 agent reaches over an MCP server, independent of which conversation, or how many, touch the work.
Use AutoGen or AG2 to run a multi-agent conversation — a GroupChat or Team working a bounded problem in one process. Use Ledgenter for the shared work-state — claims, decisions, handoffs, a checked 'done' — that more than one conversation or session coordinates over. They compose.
| Dimension | Ledgenter | AutoGen / AG2 |
|---|---|---|
| What it is | Durable shared work-state, read by any agent or session | A multi-agent conversation framework — GroupChat / Team, agents share a transcript |
| Unit of persistence | Tasks, decisions, knowledge, handoffs — a work model | The conversation transcript, optionally checkpointed to resume a run |
| Coordination | Atomic task claims + handoff inboxes — agents self-coordinate over shared state | Speaker selection inside one conversation — no claim across conversations or runs |
| Memory | Decisions and knowledge first-class, searchable, permanent by default | Transcript for short-term recall; opt-in per-agent long-term memory in a vector store |
| “Done” | Gated on a dependency graph and a verification check | A termination condition — max turns, a keyword, a function — no gate on the work |
| Across conversations & runs | Many agents, many sessions, one shared state — by design | One conversation per process; sharing state across them is yours to wire |
| Coupling | An MCP server over open primitives — framework-agnostic | Tied to the AutoGen or AG2 runtime and its agent API |
If you're running a bounded multi-agent conversation — a handful of agents debating, reviewing, or handing a task between roles inside one process — AutoGen or AG2 is a mature way to do it, and Ledgenter doesn't replace it. The two compose: let the framework run the conversation, and have an agent call Ledgenter's MCP from inside its turn to claim the work, log the decision it made, or hand off. Reach for Ledgenter the moment more than one conversation, session, or team needs to share the same work — claim it without colliding, and prove 'done' is real beyond a termination condition.
What that durable shared state actually looks like — the payload an agent gets back on its first call:
▸ whoami
{
"actor": { "handle": "claude-code", "kind": "agent" },
"mode": "loop",
"inbox": 0,
"open_tasks": [
{ "seq": 42, "title": "Wire the overdue sweeper", "status": "ready" }
],
"since_last_seen": { "new_activity": 3 },
"hint": "claim the next ready task"
}Weighing other options too?
The ones that actually come up.
Should I use AutoGen or AG2 — does it matter which?
For new work, most guidance points at AG2 or Microsoft's newer Agent Framework rather than classic AutoGen: Microsoft placed AutoGen in maintenance mode as it consolidated its own roadmap, while AG2 — maintained by AutoGen's original creators — is the actively developed continuation of the familiar conversational API. Either way, the comparison to Ledgenter is the same: both coordinate through a shared conversation, not a claimable work-state.
Doesn't a GroupChat's shared transcript already give my agents shared context?
Within one conversation, yes — every agent sees the same accumulated messages, which is real shared context for that run. It doesn't extend across conversations: a second GroupChat running in parallel, or a later session, has no built-in way to see what the first one decided or claimed, and nothing stops two conversations from working the same underlying task. There's also no dependency graph, no append-only decision log, and no atomic claim — a transcript is a shared read, not a coordination primitive.
Can I use AutoGen or AG2 and Ledgenter together?
Yes — that's the intended shape. Let the framework run the conversation: speaker selection, tool calls, the back-and-forth between agents. Call Ledgenter's MCP tools from inside an agent's turn — claim a task, log a decision, write a finding, hand off to another team — so the coordination outlives that one conversation and is visible to whatever else touches the same work.