AgentD: Coordinate Claude Code and Codex on One Project with LibraOS

Coding agents like Claude Code and Codex can already handle complex development tasks. But what happens when several agents need to work on the same application?

Coordinating tasks, sharing project context, tracking file ownership and verifying completed work can quickly become a challenge of their own.

AgentD brings multiple coding agents into one shared development workflow. Built on LibraOS, it gives agents a common foundation for coordinating work and building applications together, with searchable project memory when LibraOS Runtime is configured.

We built and launched AgentD within a week. That speed was possible because the underlying engine was already in place.

Why We Built AgentD

Some of today’s most interesting AI products are built around agents that do real work and remember what they’ve learned along the way. Yet building these products has usually required a large, well-funded engineering team.

We believe that should change.

Anyone with a strong idea and real domain expertise should be able to build their own agent platform without first developing the underlying infrastructure.

That’s the idea behind LibraOS: provide the engine so builders can focus on the products and experiences they want to create.

From Idea to Launch in One Week

To demonstrate this vision, we built AgentD and launched it within a week.

We could move that quickly because LibraOS was already there. Memory, knowledge handling and the rest of the engine were in place, so we could focus our engineering effort on the product itself.

Think about it this way: would you build your own Android or iOS just to ship an app?

AgentD shows what becomes possible when you don’t have to build the engine first.

What AgentD Does

AgentD runs on your own development machine, using the models and API keys you choose. It coordinates the coding agents your team already uses, so several agents can work together on one application.

Here are its five core capabilities.

1. One Shared Ledger

Tasks, sessions, file claims and messages live in one place. Agents can hand work to each other without resending the entire project history in every prompt.

Every worker shares one record of what has happened and what needs to happen next.

2. Plans You Approve

The planner breaks large development requests into smaller tasks, each with its own files and acceptance criteria.

Nothing starts until a person approves the plan. You decide what the agents work on before execution begins.

3. Done Means Verified

Every task comes with a check that AgentD runs itself.

A task only counts as complete when its check passes. This separates work an agent reports as finished from work that has actually met its requirements.

4. People Stay in Control

Each worker has its own budget and commits only to its own branch.

Merges, spending and deletions require human approval, and one dashboard shows what every agent is doing.

Agents can take on more development work without you giving up oversight.

5. Persistent Project Memory

With LibraOS Runtime underneath, project rules, task records and session summaries become searchable across sessions.

Agents and people can ask what happened earlier in the project and get answers that cite their sources.

Instead of starting from scratch every time a session ends, the project keeps useful context that can be retrieved when needed.

What Our First Benchmark Showed

In a small internal benchmark, AgentD’s planner built a more complete application than a single agent running on the same model. The result included more tests, seed data and documentation.

There was a trade-off: AgentD used more tokens to get there.

This was an early internal benchmark, not a universal performance claim. But it offers a useful starting point for exploring how coordinated agents approach development differently from a single agent working alone.

Getting Started

AgentD works with the API keys you already have. Use the coding models and tools you prefer, and keep full control over your own model usage. Any charges for model APIs or coding-tool subscriptions are billed directly by those providers.

A few practical notes:

• AgentD runs in your own development environment. The tested setup today is Linux.
• Task tracking, handoffs, checks and the dashboard work without LibraOS Runtime. Knowledge search and model-assisted features need a configured Runtime.
• MegaNova Gateway is optional, with its own access and billing.

AgentD Is the Proof, Not the Point

We offer AgentD for one reason: to show what LibraOS Runtime makes possible.

LibraOS Runtime is the engine that gives agents memory across sessions. It also supports knowledge packs: packaged domain expertise that helps turn a general-purpose model into a specialist.

These capabilities are not limited to coding. The same memory and knowledge layers can be brought into other kinds of applications, for example:

• Support desks, where agents can keep relevant context across customer conversations and draw on domain-specific knowledge.
• Tutoring apps, where agents can build on earlier learning sessions and specialized educational content.
• Internal research tools, where agents can retrieve project information, earlier findings and domain expertise across sessions.

The idea is simple: builders shouldn’t have to recreate memory and knowledge infrastructure every time they develop a new AI product. With LibraOS Runtime, they can focus on what makes their application different.

Start Building with AgentD

Ready to bring your coding agents together? Bring your own API key and see how multiple coding agents can work together in one development workflow.

Explore AgentD

And if the runtime were already there, what agent company would you build? We’d love to hear about it.

What’s Next?

Sign up and explore now.

🔍 Learn more: Visit our blog and documents for more insights or contact us for a demo of how MegaNova can power your AI products.

📬 Get in touch: Join our Discord community for help or Contact Us.