Ledgenter vs Claude Managed Agents
Anthropic's Claude Managed Agents runs your agent for you — a self-hosted sandbox, its own scheduler, and MCP tunnels that let it call tools and other MCP servers without you standing up the infrastructure yourself. It's the orchestration and runtime layer: you point it at a task, it manages the execution.
Ledgenter isn't a runtime and doesn't compete for that job. It's the durable, shared work-state — projects, tasks with a dependency graph, an append-only decision log, cross-agent handoffs, searchable knowledge — that any agent reads and writes over its own MCP server, independent of what's running it. Managed Agents can call Ledgenter's MCP tools the same way Claude Code or Cursor already do; the sandbox executes the run, and Ledgenter remembers what happened after the sandbox is gone.
Managed Agents runs the agent. Ledgenter is the state that's still there once the run ends — and it isn't locked to Managed Agents, or to any other runtime.
| Dimension | Ledgenter | Claude Managed Agents |
|---|---|---|
| What it is | Durable shared work-state, read by any MCP-speaking agent | Anthropic's managed sandbox + orchestration runtime |
| Job | Coordinate work across runs, agents, and sessions | Execute a run — schedule it, sandbox it, give it tool access |
| Lifetime of state | Persists across runs, sessions, and even runtimes | Scoped to the run/sandbox session being managed |
| Runtime lock-in | An MCP server any client calls — Claude Code, Cursor, Managed Agents, or none of them | Anthropic's own managed runtime |
| Coordination | Atomic task claims + handoff inboxes across a whole fleet | Whatever the run's own scheduling handles inside one session |
| Isolation model | FORCE RLS + composite tenant keys, ~145 pgTAP cross-tenant tests, provable in CI | Sandbox process isolation for the run itself — a different problem (execution isolation, not a multi-tenant data store) |
| “Done” | Gated on a dependency graph and a verification check | Whatever the run reports — no cross-run check |
| How they compose | An MCP server any runtime calls, including Managed Agents' own tunnels | Calls out to MCP servers (including Ledgenter) via its own tunnels |
If you want Anthropic to run the sandbox, the scheduling, and the tool plumbing for you, Managed Agents is the right call — that's real infrastructure most teams don't want to operate themselves, and Ledgenter doesn't replace it. The two aren't competing for the same job: Managed Agents executes a run; Ledgenter is where that run — and every run before and after it, on any runtime — leaves a durable, shared record. Point Managed Agents' MCP tunnel at Ledgenter and the sandbox gets a work-state that outlives it, the same as if the agent were running in Claude Code, a devbox cron loop, or somewhere else entirely.
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"
}The ones that actually come up.
Isn't Ledgenter just a worse version of what Managed Agents already does?
They're not doing the same job. Managed Agents runs the agent — a sandbox, a scheduler, tool access via MCP tunnels. Ledgenter doesn't run anything; it's the durable work-state a run reads and writes to over its own MCP server — tasks, decisions, handoffs, knowledge — that's still there after the sandbox shuts down. An agent needs somewhere durable to leave what it decided, and a self-hosted sandbox isn't built to be that permanent, multi-tenant record.
If I use Managed Agents, do I still need Ledgenter?
If more than one run, agent, or session ever needs to know what a previous run decided, yes. A Managed Agents sandbox executes and exits; anything it didn't write somewhere durable is gone with it. Point its MCP tunnel at Ledgenter the same way you'd wire in any other MCP server, and every run — whether it's in Managed Agents, Claude Code, or a cron loop on your own box — reads and writes the same shared state.
Why not just use whatever storage Managed Agents itself exposes?
Depends what you need it for. Anything scoped to one sandbox's own session won't outlive that run, and won't be reachable from an agent running somewhere else — a laptop session, a different vendor's runtime. Ledgenter is deliberately runtime-agnostic: an MCP server any agent calls, with DB-enforced tenant isolation proven in CI, so the record persists and stays shared no matter which runtime — or how many different ones — touch the work over time.