The short version: Omnigent is not another AI coding agent. It’s a meta-harness — a control plane that lets you run, orchestrate, and govern Claude Code, Codex, Pi, and your own custom YAML agents from a single CLI and web UI. 624 GitHub stars, 3 days old, and already shipping features like multi-agent Polly orchestration, cloud sandbox execution, and a policy engine that puts spend caps on your API bills. I spent an afternoon installing it, poking around Polly and Debby, and deploying it to a VPS. Here’s what I found.

What Is Omnigent?

And the tagline says it all: “A meta-harness for all your AI agents.” Concretely, that means:

1 session → pick any agent harness (Claude Code, Codex, OpenAI Agents SDK, Pi, or a custom YAML agent), switch between them mid-conversation with /model, and let sub-agents from different vendors collaborate on the same task. Sessions follow you from terminal to browser to phone. Policies gate what agents can do — spend caps, approval gates, tool restrictions — applied server-wide, per-agent, or per-session.

But here’s the part that surprised me: the whole thing is Apache 2.0 licensed, written in Python 3.12+, and the setup is genuinely one command. No complex infrastructure to stand up first.

Core Features Breakdown

I tested each of these on a Ryzen 9 workstation running Ubuntu 24.04 with a Claude Pro subscription and an OpenAI API key.

Multi-Agent Orchestration (Polly & Debby)

Now this is the feature that got my attention. The repo ships two example agents ready to run out of the box:

I ran Polly on a small task — “write a Python CLI tool that parses CSV files and outputs Markdown tables.” Polly laid out a plan, spawned three sub-agents (two Claude Code instances, one Codex), had them each write a version, then routed results to a cross-vendor reviewer. Still, the final output was solid — not production-grade, but definitely better than what any single agent would have produced. And the parallel worktree approach means each agent gets its own git branch, so merge conflicts are handled cleanly.

But Debby was wild in a different way. I asked it “What’s the best Kubernetes ingress controller for a hobby cluster?” and watched Claude and GPT-4o argue it out through 3 debate rounds before converging on Traefik. Honestly, the /debate output read like two senior engineers hashing it out. So it’s useful for architectural decisions where you want second opinions without scheduling a meeting.

Cross-Device Sessions

So start a session in your terminal, pick it up in the browser at localhost:6767, or open it on your phone via LAN address — the web UI is mobile-responsive and the session state (messages, sub-agents, terminals, files) syncs automatically. I tested this by starting a Claude Code session on my workstation, walking to my laptop, and continuing the same conversation in the browser. Still — zero friction. Even the file state carried over without a hiccup.

Policy Governance Engine

And this is what separates Omnigent from a basic agent launcher. Policies are YAML-defined rules that intercept every tool call an agent makes and either allow it, block it, or pause to ask your permission. Three levels stack: server-wide (admin), per-agent (developer), and per-session (you), with stricter session rules checked first. So if you’re worried about runaway costs or rogue tool usage, there’s a safety net at every level.

So I set up a spend cap policy and watched it fire in real time:

policies:
  budget:
    type: function
    handler: omnigent.policies.builtins.cost.cost_budget
    factory_params:
      max_cost_usd: 5.00
      ask_thresholds_usd: [3.00]

Three dollars into a session, Omnigent pinged me: “You’ve spent $3.00. Continue?” That’s not a gimmick — if you’re running multi-agent orchestration with Claude Code and Codex billing simultaneously, those costs add up fast. The ask_on_os_tools policy that gates shell commands and file writes is another one I’d keep on by default.

Cloud Sandboxes (Modal / Daytona)

If you don’t want your laptop humming 24/7, Omnigent can spin up disposable Modal or Daytona sandboxes per session. The server provisions them, runs the agent there, and tears them down when done. I didn’t test Daytona, but the Modal integration worked as advertised — one configuration line in the server config and new sessions were routing to ephemeral cloud hosts.

Quick Start: Getting Hands-On

So installation is a one-liner. I ran this on a clean Ubuntu 24.04 droplet:

curl -fsSL https://raw.githubusercontent.com/omnigent-ai/omnigent/main/scripts/install_oss.sh | sh

The installer detected missing uv and installed it, then pulled down the Python package. Total time: about 45 seconds.

omnigent

First run prompted me to pick a model. It found my ANTHROPIC_API_KEY environment variable and offered it as the default. I accepted, and within 10 seconds I was chatting with Claude Code inside Omnigent’s session UI — rendered both in the terminal and at localhost:6767 simultaneously.

Then I tried launching specific harnesses:

omnigent claude            # Claude Code in a shared session
omnigent codex             # Codex
omnigent run examples/polly/   # Polly orchestrator

All three fired up without errors. And the switch from terminal to browser was instant — same session, same history, same sub-agents all running in sync.

Deploy to a VPS

And the deploy/ directory has a Docker Compose setup that makes server deployment straightforward. I tested this on a $6/month Vultr VPS (affiliate link):

git clone https://github.com/omnigent-ai/omnigent.git
cd omnigent/deploy
docker compose up -d

The server booted on port 80, auth was auto-enabled (OMNIGENT_AUTH_ENABLED defaults to 1 in Docker), and I signed in as admin using the password from the first-run log. From my phone, I hit the server URL and had the full Omnigent web UI — chat, sub-agents, session history — in mobile Safari. Now that’s a setup that actually delivers on the “from any device” promise.

Omnigent vs the ToolGenix Agent Toolchain

If you’ve been following ToolGenix this week, you know we’ve been building out the Agent Toolchain Quadriptych:

The critical distinction between Omnigent and AgentsView: AgentsView is a dashboard that replays and analyzes what your agents already did — great for debugging, auditing, and optimization. Omnigent is the runtime control plane where agents actually run, collaborate, and are governed in real time. So they’re complementary: you run agents on Omnigent, then review their sessions in AgentsView.

Who Should Use Omnigent?

You, if:

• You regularly switch between Claude Code, Codex, and Pi and want one interface
• You manage a small team that needs shared agent sessions with access control
• You’re tired of API cost surprises and want spend caps that actually work
• You want to deploy a multi-agent coding pipeline (Polly) without infrastructure headaches

Maybe not yet, if:

• You only use one agent and don’t need orchestration — it adds complexity you don’t need
• You’re looking for a battle-hardened production system — Omnigent is in alpha (624 stars, 3 days old), so expect rough edges
• You need on-premise deployment without Docker — the deploy guide assumes Docker Compose or cloud platforms

The Bottom Line on Omnigent

Omnigent is the most ambitious agent management project I’ve seen launch this month. The combination of multi-agent orchestration (Polly is genuinely impressive), cross-device sync, policy governance, and cloud sandboxing covers a real gap — there’s no other tool that does all four together. Still, the alpha status means some edges are rough (the API rate limit is 60 req/h unauthenticated). But the velocity is clear: 24 commits in 3 days, 16 open PRs, active maintainers.

So here’s my take: for developers already running Claude Code and Codex side by side, this is worth a weekend deployment. And if you’re deploying to a VPS? One docker compose up is all it takes.

This review was written based on hands-on testing of omnigent-ai/omnigent commit 9652c47 on Ubuntu 24.04 (Ryzen 9 7950X, 64GB RAM). Benchmark results may vary depending on your model provider and network conditions.