Omnara Managed Agent Platform
Run persistent AI agents across your own machines and cloud sandboxes through one API.
- Source repo
- omnara-ai/omnara
- Stars
- ★ 3.2k
- Last updated
- today
- License
- Apache-2.0
- Primary language
- Go
- FA score
- 65/100 · Some gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformCodex · Claude Code · Claude.ai · OpenAI API · Claude API
- Cost
- Free tier plus a paid hosted plan
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- Engineering teams launching code execution tasks from an application API and running them across their own VMs or sandboxes.
- Not a fit if
- Teams requiring a single-vendor managed agent platform
- Teams unable to operate a Docker Compose deployment
- Source review
- 65/100 · Some gaps
What does this agent do, and when should you use it?
Omnara is an open-source managed agent platform that can be self-hosted or used through Omnara Cloud. Your app, CLI, and dashboard use the same REST API to create agents, send messages, handle approvals, and stream events. Stateless workers call configured models and run tools, while Postgres stores each event so an agent can resume after a crash or restart; machines connect through the Omnara daemon. It supports compatible OpenAI and Anthropic endpoints, among other providers, and can use your machines or sandboxes from multiple providers. Teams can launch and manage agents through the TypeScript SDK, CLI, MCP, and Slack, Discord, or GitHub integrations; self-hosted deployments keep agent history in their own Postgres database.
Configure instructions, models, tools, and machines in agent.yaml or through the REST API, then create an agent. A worker builds the model context, calls the configured model, and runs built-in, MCP, or custom tools; machines can run shell commands and edit files. The platform records events in Postgres and streams them back. Tool permissions can allow a call immediately, wait for human approval, or block it. Users can send follow-up messages and handle approvals through the CLI, dashboard, or API, and can configure scheduled triggers and Slack, Discord, or GitHub integrations.
- Engineering teams launching code execution tasks from an application API and running them across their own VMs or sandboxes.
- Teams that want agents to respond to mentions, ask questions, and request approvals in Slack or Discord threads.
- GitHub maintainers triggering reviews when a pull request opens or is mentioned, then having an agent inspect the diff and leave comments.
- Self-hosting teams that want agent histories in Postgres for querying, analytics, or evaluation datasets.
- Operations teams that need scheduled agent launches or messages sent to existing agents.
How do you install or deploy this agent?
For Omnara Cloud, sign in to use the first project's omnara-openrouter model provider and default-pool sandbox pool. The CLI requires Node.js 22 or newer:
npx omnara agents launch --file agent.yaml \
--name "Machine assistant" \
--message "Report this machine's operating system and free disk space."Self-hosting requires Docker with Compose:
git clone https://github.com/omnara-ai/omnara.git
cd omnara
docker compose -f compose.yaml --profile app up -dOpen http://localhost:8000 and sign up. A new instance has no models or machines, so add a model provider and model, connect a machine, and share them with the project. Follow the self-hosting deployment and configuration guides for production.
How do you use this agent?
The CLI opens a browser sign-in flow if you are not logged in. Create agent.yaml with your model and machine pool, then launch and chat:
npx omnara agents launch --file agent.yaml \
--name "Machine assistant" \
--message "Report this machine's operating system and free disk space."
npx omnara agents chat <agent-id>To use the TypeScript SDK, create an API key and export it as OMNARA_TOKEN, install @omnara/sdk, and get the organization and project IDs with npx omnara config:
npm install @omnara/sdkimport { readFile } from 'node:fs/promises'
import { bearerToken, createOmnaraClient, openAgentEventStream, sdk } from '@omnara/sdk'
const client = createOmnaraClient({ auth: bearerToken(process.env.OMNARA_TOKEN!) })
const path = { orgID: 'org_...', projectID: 'proj_...' }
const config = await sdk.createAgentConfig({
client,
path,
body: { source: await readFile('agent.yaml', 'utf8'), source_format: 'yaml' },
})
const launched = await sdk.createAgent({
client,
path,
body: { config: config.data.id, message: "Report this machine's free disk space." },
})
const agentID = launched.data.agent.id
for await (const event of openAgentEventStream({ client, path: { ...path, agentID } })) {
console.log(event)
}What are this agent's strengths and limitations?
- The same API and configuration format work on Omnara Cloud and self-hosted deployments, with a choice of compatible model providers and machine environments.
- Postgres stores step-by-step events as agent state; the README says workers can resume an agent from that record after a restart.
- Per-tool permissions, event streaming, and human approvals support supervised execution.
- Self-hosting keeps agent history in your Postgres database, and the platform exposes a REST API, TypeScript SDK, CLI, and MCP server.
- Production self-hosting takes more than one command: it requires Docker Compose plus model, machine, and deployment configuration.
- The hosted quickstart requires an Omnara Cloud account; using Omnara-provided models or sandboxes can incur usage charges.
- Agent execution depends on a reachable platform API, configured model endpoint, and machine or sandbox; the README does not describe offline operation.
- The deployment and integrations involve multiple components, including Postgres, Redis, blob storage, workers, and a machine daemon, which add operational work.
How does this agent compare with similar options?
Compared with Claude Managed Agents and OpenAI's Agents API, Omnara can be self-hosted, use compatible models, and run on a choice of machine environments. The other two are hosted by Anthropic and OpenAI respectively, with models centered on their own ecosystems. The README suggests those hosted services when you want the vendor to operate the platform and use its models; Omnara fits teams that want their own infrastructure or model choice.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Omnara Managed Agent Platform This agent | 65 · Some gaps | Hosted serviceFreemium | ★ 3.2k | today | Go | Codex · Claude Code · Claude.ai · OpenAI API · Claude API |
| TrueForge | 67 · Some gaps | CLIFree + model costs | ★ 6.4k | 1d ago | TypeScript | OpenAI API · Claude API |
| LlamaAgents | 66 · Some gaps | Library / SDKFree + model costs | ★ 462 | today | Python | — |
| wigolo | 54 · Major gaps | CLIFree + model costs | ★ 5.5k | 3d ago | TypeScript | Codex · Claude Code · OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
The permissions guide says agents can use only tools in the current config, changing the set requires a config update, and tools support always_allow, always_ask, and always_deny. This supports least privilege and human approval, but built-in and custom tools default to always_allow, so the scores are not full. The README and docs describe connections to models, tools, machines, and external integrations, and give some visibility into permissions, credential sharing, and event records. Self-hosted history stays in the operator's Postgres and credentials use secrets, but the supplied files do not detail encryption, retention, or access auditing. CI declares govulncheck and the dependency manifest is substantial, but no scan result or remediation evidence is supplied. Agent cancellation/archive and durable event logs offer partial recovery paths; no rollback mechanism is described. Repository and project naming provide some attribution, but publisher identity is unverified, so provenance is only partly clear.
The README's account of the API, Postgres event log, and stateless workers is consistent with its persistence and event-stream descriptions. The CI workflow lists static checks, unit, integration, and end-to-end jobs, but this review did not run them. Operation depends on Docker, databases, Redis, model services, machines, or cloud resources; the supplied material does not establish their availability guarantees. API and CLI examples provide limited HTTP error-handling detail, and the supplied files say little about runtime error messages, retries, or diagnosis, so these scores remain partial.
The README identifies cloud and self-hosted deployments, multiple models, machines, tools, integrations, schedules, and developer APIs as supported audiences and scenarios, justifying a high score. Tool permissions, machine sources, and model configuration show capability boundaries, but high-level claims include command execution, file edits, and third-party services; concrete isolation limits depend on deployment and config and are not fully explained. Triggers include CLI/API, Slack, Discord, GitHub, and cron, with examples but not complete trigger constraints. Docker Compose, local development, production-guide links, and several interfaces support environment fit, while the supplied files do not cover every environment requirement or production setting.
The README is organized into quickstart, self-hosting, architecture, features, examples, FAQ, development, and community, with clear documentation links. It gives cloud and self-host install steps, while production details are external; it explicitly says local defaults are insecure. Product, CLI, SDK, API, and config naming are mostly consistent, and examples and FAQ are substantial, but the supplied files do not establish naming stability across versions. The LICENSE clearly provides Apache 2.0, earning full marks. The README links a changelog and the security policy says fixes track main before stable releases, but no concrete release history is supplied here. Security reporting routes and contact are clear; maintenance responsibility rests on project statements and an unverified publisher, with no named maintainers or support commitment in the supplied material.
Users can launch through CLI, REST, SDK, or dashboard, and the repository provides event streaming, inputs, permission modes, and agent examples. This is useful for common integrations, though the evidence is mostly documentation and claims rather than concrete runtime outputs. Hosting, durable state, multiple models and machines, and permission controls add substantial capability beyond an agent loop embedded in an application. Self-hosting has no platform fee but requires operating Postgres, Redis, storage, workers, and machines; cloud pricing is described as usage-based for models and sandboxes, but the supplied information is not enough to estimate total operating cost.
The README links major architecture and capability claims to configuration, permissions, API, and deployment documentation; examples and the API definition are also identified. The permissions guide gives concrete modes and defaults. The README, quickstart, permissions guide, and CI corroborate some concepts, but the supplied material lacks implementation source or scan output, so runtime enforcement cannot be independently checked here. Documentation distinguishes defaults, config examples, and product descriptions, but claims about provider compatibility, recovery, and isolation are still assertions in places and do not always state their conditions, so full marks are not justified.
- The README explicitly says local self-host defaults are insecure; harden deployments using the deployment and configuration guidance.
- Built-in and custom tools default to immediate execution without approval; review tool settings and require approval or denial for external write actions.
- Self-hosted agent history resides in the operator's database, while tools, models, and machines process task data; operators should assess retention, credential protection, and network exposure.