Listen to this Post
Introduction
The AI coding assistant landscape has fractured into a dozen competing terminals, each with its own setup, commands, and workflow quirks. Developers now juggle Claude Code, Codex, Cursor, OpenCode, Hermes, and Pi — but switching between them means restarting context, reconfiguring environments, and losing continuity. Omnigent emerges as the open-source meta-harness that sits above all these agents, providing a single orchestration layer that lets you swap, combine, and govern any AI coding agent through one consistent interface — with sessions that follow you from terminal to browser to phone.
Learning Objectives
- Master unified agent orchestration — Learn to run Claude Code, Codex, Cursor, OpenCode, Hermes, and Pi through a single Omnigent interface without rewriting workflows
- Implement multi-agent collaboration — Understand how to delegate tasks in parallel across multiple agents running in isolated environments, then route outputs to reviewer agents
- Enforce security policies at three levels — Configure server-wide, per-agent, and per-session policies to control shell commands, spend caps, and tool access
- Deploy cloud sandboxes for agent execution — Launch disposable environments via Modal, Daytona, E2B, Kubernetes, and other providers
- Build custom YAML-defined agents — Create personalized agents with local Python functions, MCP servers, and sub-agent supervision
- Installing Omnigent: One Command to Rule Them All
Omnigent eliminates the friction of setting up multiple agent environments. The bootstrap installer handles dependencies automatically, though you can also install manually via Python’s `uv` or pip.
One-Line Install (Linux/macOS)
curl -fsSL https://raw.githubusercontent.com/omnigent-ai/omnigent/main/scripts/install_oss.sh | sh
This installs Omnigent and all required dependencies.
Manual Installation Options
Using uv (recommended) uv tool install omnigent Using pip pip install "omnigent" Using Homebrew (macOS) brew install omnigent-ai/tap/omnigent Direct from repository uv tool install -q --python 3.12 git+https://github.com/omnigent-ai/omnigent.git
Prerequisites
The installer checks for these dependencies and offers to install missing ones:
| Requirement | Purpose |
|-||
| Python 3.12+ | Core runtime |
| uv | Python package installer |
| git | Version control |
| Node.js 22 LTS+ with npm | Required for Claude, Codex, OpenCode, Pi harnesses |
| tmux | Terminal wrappers for native agent sessions |
| bubblewrap (bwrap) — Linux only | OS-level sandboxing (mandatory on Linux) |
| seatbelt — macOS built-in | Native sandbox (no extra install) |
Windows Native Support
Omnigent runs natively on Windows in degraded mode. Install directly with uv:
uv tool install --python 3.12 omnigent
What works: omnigent server, web UI, and SDK-based harnesses. Agents run under Windows Job Objects for process-tree containment.
What doesn’t work on native Windows: tmux/PTY terminal wrappers, bwrap/seatbelt filesystem and network sandboxing, and the L7 egress proxy. Use WSL or Linux/macOS for full isolation.
Updating Omnigent
omni upgrade Drains sessions, stops server, upgrades omni upgrade --check Check if new version is available omni upgrade --force Stop sessions immediately
The `omni upgrade` command detects your installation method and runs the matching upgrade.
2. Session Management: Your Agents, Everywhere
Omnigent’s session architecture is the foundation of its value proposition. Sessions persist across devices — start in your terminal, continue in the browser, pick it up on your phone.
Starting a Session
Start the Omnigent server omni server Run an agent session omnigent run Or use the native terminal wrapper for a specific harness omnigent claude Wraps Claude Code omnigent codex Wraps Codex omnigent cursor Wraps Cursor omnigent pi Wraps Pi
Session Sync Architecture
Messages, sub-agents, terminals, and files stay synchronized across every surface. The session state is stored server-side, enabling:
- Cross-device continuity — Pick up exactly where you left off
- Real-time collaboration — Share a session so teammates can watch agents work live, co-drive, or fork conversations
- Persistent history — Every interaction, terminal output, and file edit is preserved
Native Terminal Wrappers
Omnigent wraps each agent’s native CLI in a `tmux` session with PTY support:
omnigent claude Claude Code native terminal omnigent codex Codex native terminal omnigent cursor Cursor native terminal omnigent hermes Hermes native terminal omnigent kiro Kiro native terminal (requires Kiro CLI) omnigent pi Pi native terminal
On Linux, each wrapper runs inside a `bubblewrap` OS sandbox for mandatory isolation.
3. Multi-Agent Orchestration: Collaboration Without Chaos
The killer feature: run multiple agents in the same session, delegate tasks across them, and route outputs between agents — all from one interface.
Parallel Task Delegation
Point one agent at another’s work. Delegate tasks in parallel across Claude Code, Codex, and Pi running in separate git worktrees, then route the diffs to a reviewer from a different vendor — all from one session.
Built-in Custom Agents
Omnigent ships with two pre-configured agents:
- Polly — A multi-agent coding orchestrator that coordinates multiple coding agents
- Debby — A dual-head brainstorming agent combining Claude and GPT
Agent-to-Agent Communication
The orchestration layer enables:
- One agent reviewing another’s work
- Splitting tasks across agents with different strengths
- Routing outputs from one agent as inputs to another
- Supervisor agents delegating to sub-agents
4. Policy Enforcement: Governance at Three Levels
The most critical security feature in Omnigent is its three-tier policy system. Unlike orchestration layers that bolt on policies as an afterthought, Omnigent enforces them consistently across server-wide, per-agent, and per-session levels — with stricter session rules checked first.
Policy Configuration in YAML
policies: Ask before shell commands or file writes approve_shell: type: function handler: omnigent.policies.builtins.safety.ask_on_os_tools Cap tool calls per session cap_calls: type: function handler: omnigent.policies.builtins.safety.max_tool_calls_per_session factory_params: limit: 50 Hard spend cap with soft warning budget: type: function handler: omnigent.policies.builtins.cost.cost_budget factory_params: max_cost_usd: 5.00 ask_thresholds_usd: [3.00]
Policy Enforcement Levels
| Level | Scope | Applied By |
|-|-||
| Server-wide | All agents and sessions | Administrator |
| Per-agent | Specific agent only | Developer |
| Per-session | Single chat session | User |
Available Policy Builtins
– `ask_on_os_tools` — Pause for approval before shell commands
– `max_tool_calls_per_session` — Limit tool usage
– `cost_budget` — Hard spend cap with soft warnings
– Block/allow specific tools or file paths
Using Policies in the Web UI
Open a session’s info panel to browse available policies and toggle them on or off. Or simply ask in chat: “Add a policy that asks me before running shell commands” — the agent sets it up for you.
5. Writing Custom Agents with YAML
Agents are defined in short YAML files. You don’t even need to write them by hand — describe the agent you want in any Omnigent chat and it authors the file for you.
Basic Agent YAML Structure
name: my_data_analyst prompt: You are a helpful data analyst specializing in CSV datasets. executor: harness: claude-sdk or: claude-1ative, codex, cursor, hermes, opencode, pi tools: Local Python function (schema auto-generated from signature) word_count: type: function callable: mypackage.mymodule.word_count MCP server (local command or remote URL) docs: type: mcp url: https://example.com/mcp Sub-agent for delegation researcher: type: agent prompt: Search for relevant information and summarize it. tools: word_count: inherit
Running a Custom Agent
omnigent run path/to/my_agent.yaml
Key YAML Fields
| Field | Description |
|-|-|
| `name` | Agent identifier |
| `prompt` | System prompt defining agent behavior |
| `executor.harness` | Which underlying agent harness to use |
| `tools` | Local functions, MCP servers, or sub-agents |
| `policies` | Per-agent policy overrides |
The full schema is documented in the Agent YAML Spec.
6. Cloud Sandboxes: Agent Execution Without Your Laptop
Run agents in disposable cloud sandboxes — no laptop required. Omnigent supports launching sessions in multiple sandbox providers:
Supported Sandbox Providers
| Provider | Description |
|-|-|
| Modal | Serverless cloud platform |
| Daytona | Development environment manager |
| Islo | Isolated development environments |
| E2B | AI agent sandbox |
| CoreWeave | Cloud sandboxes |
| Kubernetes | Container orchestration |
| NVIDIA OpenShell | GPU-accelerated sandboxes |
| Boxlite | Lightweight containers |
| Databricks | Data workspace sandboxes |
Launching a Sandbox Session
Run a session in a Modal sandbox omnigent run --sandbox modal Run in a Kubernetes pod omnigent run --sandbox kubernetes Use a specific Databricks workspace omnigent run --sandbox databricks --workspace my-workspace
Sandbox Benefits
- Disposable environments — Fresh state for each session
- No local resource consumption — Offload compute to the cloud
- Isolation — Agents run in contained environments
- Scalability — Launch multiple parallel sandboxes
7. Collaboration and Session Sharing
Omnigent transforms individual agent sessions into collaborative workspaces.
Real-Time Team Collaboration
Share a session so teammates can:
- Chat with your agent and watch it work live
- Co-drive it on your machine
- Fork the conversation to continue on their own
- Review agent outputs and provide feedback
Cross-Device Continuity
Sessions follow you across:
- Terminal — Native CLI experience
- Browser — Web UI with full session control
- Phone — Mobile access via responsive interface
- macOS Desktop App — Native application
Multi-Device Sync
Messages, sub-agents, terminals, and files stay in sync across every surface. Start a complex coding task on your desktop, continue reviewing on your phone during commute, and finalize in the browser from any machine.
What Undercode Say
- Unified orchestration changes the game — The ability to swap between Claude Code, Codex, Cursor, and Pi without rewriting workflows eliminates the biggest friction point in AI-assisted development. No more context loss when switching agents.
-
Three-tier policy enforcement is security done right — Most orchestration layers treat policies as an afterthought, leading to inconsistent behavior depending on which agent runs underneath. Omnigent’s server-agent-session hierarchy with stricter session rules checked first ensures predictable governance.
-
Session persistence across devices is the UX differentiator — The terminal-browser-phone sync isn’t just convenience; it fundamentally changes how developers interact with AI agents. Long-running processes, output logs, and file states persist across surfaces — a requirement for serious production use.
-
Custom YAML agents democratize AI automation — Non-developers can describe agents in natural language and have Omnigent generate the YAML. This lowers the barrier to creating specialized agents for specific workflows.
-
The sandbox ecosystem matters — Supporting Modal, Daytona, E2B, Kubernetes, and Databricks gives teams flexibility to run agents where their data and compliance requirements live.
-
Windows support is limited but acknowledges reality — Native Windows runs in degraded mode without filesystem or network sandboxing. Teams requiring full isolation should use WSL or Linux/macOS — a pragmatic trade-off.
-
Open source with 6.4k stars signals community trust — The project’s rapid adoption (6.4k stars on GitHub) indicates genuine developer interest in solving the multi-agent fragmentation problem.
Prediction
+1 The meta-harness pattern will become the dominant way teams interact with AI coding agents within 18 months. As the number of specialized AI agents grows, the friction of switching contexts will outweigh the benefits of using multiple tools — exactly the problem Omnigent solves.
+1 Policy enforcement at the orchestration layer will become a security best practice. Organizations will mandate meta-harnesses to maintain consistent governance across all AI tooling, preventing shadow IT where agents operate without oversight.
-1 Native Windows users will face frustration until filesystem and network sandboxing parity is achieved. The current degraded mode may push Windows-centric teams toward alternatives or WSL, fragmenting adoption.
+1 The ability to run agents in cloud sandboxes will accelerate enterprise adoption. Security teams will prefer disposable environments over local agent execution, reducing risk from malicious tool calls or data exfiltration.
+1 Custom YAML agents will emerge as a new category of “agent-as-code” artifacts, similar to Infrastructure-as-Code. Teams will build internal agent libraries, sharing and versioning agent definitions like they do with Terraform modules.
-1 Multi-agent orchestration introduces new failure modes — agent A’s output may break agent B’s input expectations, and debugging distributed agent failures will require new observability tooling not yet mature in the ecosystem.
+1 The open-source nature of Omnigent (6.4k stars) positions it as the Linux of AI agent orchestration — an open standard that vendors will need to support, preventing lock-in to any single agent provider.
GitHub Repository: https://github.com/omnigent-ai/omnigent
▶️ Related Video (72% Match):
🎯Let’s Practice For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
IT/Security Reporter URL:
Reported By: Sumanth077 The – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
