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

At a glance

How it runs
Hosted serviceCLILibrary / SDK
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
Node.js 22 or newerDocker with ComposeShell / CLINetwork accessLocal filesystemMCP Server
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.

  1. Engineering teams launching code execution tasks from an application API and running them across their own VMs or sandboxes.
  2. Teams that want agents to respond to mentions, ask questions, and request approvals in Slack or Discord threads.
  3. GitHub maintainers triggering reviews when a pull request opens or is mentioned, then having an agent inspect the diff and leave comments.
  4. Self-hosting teams that want agent histories in Postgres for querying, analytics, or evaluation datasets.
  5. 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 -d

Open 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/sdk
import { 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?

Pros
  • 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.
Limitations
  • 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?

FollowAgents source review · FARS-2.1
Some gaps
65/ 100 5-point scale 3.3 / 5
Trust 17/29
Reliability 6/14
Adaptability 14/18
Convention 13/18
Effectiveness 10/13
Verifiability 5/8
Why each dimension lost points
Trust17 / 29 · 2.9/5

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.

Reliability6 / 14 · 2.1/5

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.

Adaptability14 / 18 · 3.9/5

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.

Convention13 / 18 · 3.6/5

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.

Effectiveness10 / 13 · 3.8/5

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.

Verifiability5 / 8 · 3.1/5

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.

Risks and how to mitigate them
  • 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.
Evidence confidence: Low Reviewed Oct 24, 2026 Reviewed revision 9a5fe25398bd
See the full review method →

FAQ

Can I use it for free?
The self-hosted software is free. Omnara Cloud has no platform fee when you bring your own model keys and machines; Omnara-provided models and sandboxes are billed by usage.
Which models are supported?
Compatible OpenAI Responses, OpenAI Chat Completions, and Anthropic Messages endpoints are supported. The README names OpenAI, Anthropic, OpenRouter, Amazon Bedrock, LiteLLM, and Ollama.
Can a tool call require human approval?
Yes. Each tool can run immediately, wait for human approval, or be blocked. The agent waits while an approval is pending.
What happens after a crash or machine disconnect?
Each step is stored in Postgres, allowing a worker to resume from the record. If a laptop goes offline, the README says the agent can continue in a sandbox and sync work back with git.
What does self-hosting require?
Local startup requires Docker Compose. You must also add a model provider and model, connect a machine, and share them with a project. Use the deployment and configuration guides for production.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents