Omnigent Is Building the Control Plane for AI Agents
A meta-harness that sits above Claude Code, Codex, and custom agents, combining sandboxing, live session sync, and cross-tool orchestration into one workspace.
- Omnigent’s real claim is not that it can run agents, but that it can govern them as a shared system.
- The watch-set sync model turns sessions into live collaborative state instead of simple request-response chat.
- Its thin desktop wrapper is a product choice, because it keeps the same workspace and policy model across web and native use.
- Polly and Debby are not side demos, they are proof that the meta-harness can compose, review, and debate across tools.
Omnigent is not a chatbot. It is a control plane.
Omnigent is easiest to understand if you stop thinking about it as another agent app. It sits above the tools people already use, including Claude Code, Codex, Pi, and custom agents, and turns them into interoperable parts of a larger workspace. That is why the repo keeps coming back to the same idea: composition, control, and collaboration.
The problem is that LLM capabilities are wrapped into an agent harness, and these harnesses have different interfaces that make combining them or swapping them difficult. So we built Omnigent: a meta-harness that sits above the agents you already use (Claude Code, Codex, Pi, or custom agents) and makes them interoperable parts of a richer system.
That framing matters because it changes the product category. Most agent tools optimize a single assistant. Omnigent optimizes the system around assistants: who can run, what can be shared, what can be watched, and what happens when tools disagree.
The real breakthrough is shared, live agent state
The most revealing code in the repo is the sync layer around SessionUpdatesProvider. It does not treat sessions like dead records waiting for a refresh. It treats them like a live board with a watch set, a stream of updates, and a cache that can be patched in place when the server proves nothing has drifted.
The point is not just speed. It is selective consistency. The client declares what it cares about, the server emits only those frames, and the UI can stay responsive because the local state is updated surgically instead of being blown away and reloaded.
Why the desktop app is intentionally thin
Omnigent’s Electron app is not trying to become a separate product surface. It is a wrapper around the same server-hosted SPA, which keeps the web and desktop experiences aligned. That is a strong architectural choice, because it avoids the usual split where native and web versions drift apart in behavior, permissions, and collaboration semantics.
| Layer | Omnigent | Traditional desktop app |
|---|---|---|
| UI source | One shared SPA | Separate native shell with its own behavior |
| Update path | Server-hosted UI reused everywhere | Desktop and web can diverge over time |
| Collaboration model | Shared sessions and watch sets | Usually local-first or siloed |
| Product effect | Thin client, consistent control plane | Heavier app, more platform drift |
That thinness is not a weakness. It lets the product keep the same mental model whether you are in a browser, a desktop window, or a shared session view.
Trust is a feature, not a layer
A system that runs multiple agent harnesses needs containment before it needs ambition. Omnigent leans into that with sandboxing, harness isolation, and approval flows. On Linux, the repo relies on bubblewrap for OS-level isolation, which signals the project’s posture clearly: treat agent execution as untrusted by default.
A runner wraps any agent in a sandboxed session with a uniform API. A server provides policies and sharing, and exposes every session over the terminal, the app, and web APIs.
That is the real prerequisite for multi-agent work. Once several tools can act in the same workspace, the question is no longer just what they can do. It becomes what they are allowed to touch, how their actions are reviewed, and when the system should stop and ask a human.
Polly and Debby show the thesis in action
Polly and Debby are the proof points that keep the meta-harness idea from sounding abstract. Polly splits coding work across harnesses, uses separate worktrees, and pushes cross-vendor review into the flow. Debby does something different but equally revealing: it stages debate between models instead of pretending one model should have the final word every time.
| Orchestrator | What it demonstrates | Why it matters |
|---|---|---|
| Polly | Cross-vendor coding in separate worktrees | Shows that Omnigent can compose tools, not just launch them |
| Debby | Multi-model debate | Shows that disagreement can be a workflow, not a failure |
| Shared session layer | Live supervision across devices | Shows that orchestration and collaboration are the same product problem |
These are not decorative demos. They are the design thesis made concrete. Omnigent is trying to make multiple harnesses feel like coordinated teammates inside one governed environment.
Why Omnigent sits above AutoGen, CrewAI, and LangGraph
The cleanest comparison is about layers, not features. AutoGen, CrewAI, and LangGraph coordinate agents inside a framework. Omnigent can sit above existing harnesses and terminal tools, which means it is trying to unify the work surface rather than prescribe the implementation from scratch.
| Project | Layer in the stack | What it orchestrates | Wraps existing tools? | Governance posture |
|---|---|---|---|---|
| Omnigent | Meta-harness above agents | Harnesses, sessions, worktrees, sharing | Yes | Sandboxed, supervised by default |
| AutoGen | Agent framework | Agent logic and conversations | Usually no | Depends on how you build it |
| CrewAI | Orchestration framework | Roles and task flow | Usually no | Framework-level, not workspace-level |
| LangGraph | Graph-based agent framework | Stateful agent flows | Usually no | Framework-level, user-defined |
| Claude Code / Codex | Agent harness | A single coding agent | No | Tool-level, not multi-tool governance |
That does not make Omnigent categorically better. It makes it one layer higher. If you already have agents, the value is not replacing them. It is giving them a shared operating surface with rules, sync, and supervision.
The bigger bet is that agents need governance
Omnigent’s deepest bet is that the next agent product category will look less like a clever assistant and more like managed infrastructure. The winners will not just answer prompts well. They will make composition safe, collaboration visible, and tool sprawl governable.
That is why the repo feels closer to an operating layer than a wrapper. It is trying to make agent work observable and composable at the same time, which is a harder problem than shipping another chat box.





