Hacker News project Omnara aims to replace Claude Managed Agents. It brings Agent Loop execution, sandboxes, permissions, and Postgres state management into a single open-source API. For teams that need Agents to run continuously in the background, this can be simpler than assembling queues, execution environments, and recovery mechanisms, though it also introduces another layer of platform dependency.
Original project: https://github.com/omnara-ai/omnara
Omnara Is More Than an Agent SDK
Omnara positions itself as an open-source alternative to Claude Managed Agents.
It is not simply an API wrapper around model calls or another layer of abstractions over LangChain and LangGraph. Its project summary is direct: developers create an Agent with one API call, after which Omnara runs the Agent Loop.
Developers send messages and receive events as a stream. The Agent executes commands in an isolated sandbox. The runtime manages secrets, permissions, and RBAC. Each Agent's state is written to Postgres, allowing work to continue after the service restarts.
This goes beyond building a chatbot that can call tools. Omnara provides a control plane for the infrastructure required to run Agents continuously.
Many Agent SDKs focus on how to describe a workflow. Developers typically handle how nodes connect, how tools are registered, how events trigger callbacks, and how the process stays alive.
These SDKs often run as Python or TypeScript processes. You start one locally, and the Agent executes on your machine. When the process exits, so does the job.
Omnara is closer to an Agent Runtime. According to the project summary, developers create an Agent through the API and the platform keeps its Agent Loop running. Users can message the Agent and receive the events it produces through a streaming API.
The critical difference is the word “continuously.”
A genuinely useful background Agent must handle at least these conditions:
- A tool call takes longer than a normal HTTP request.
- A job needs to wait for an external event without keeping the model occupied.
- A task must survive a container or host restart.
- Different users must not share secrets they should not have access to.
- An uncontrolled shell command must not affect other jobs.
The boundary between an Agent SDK and an Agent Runtime therefore lies in lifecycle management, not prompt templates.
Omnara places that responsibility in a managed service. Callers see an Agent API, while the underlying system handles execution environments, state, and control permissions.
Create an Agent with One API Call
Omnara deliberately keeps the integration thin.
First, create an Agent:
from omnara import Omnara
client = Omnara(api_key="YOUR_API_KEY")
agent = client.agents.create(
name="research-agent",
instructions="Research the assigned topic and save the findings.",
)Then send it a message and consume the streamed events:
for event in client.agents.message(
agent.id,
message="Find three reliable sources and summarize their key claims.",
):
print(event)The structure of this code matters more than its implementation details. Creation and interaction are separate. The Agent first becomes an object in the platform, then receives messages. Each interaction produces a stream of events.
The client does not need to maintain a long-lived connection to drive the reasoning loop. The platform runs the Agent Loop, the model decides the next action, the sandbox executes it, and the events stream back to the caller.
This also explains why Omnara is more than an SDK. SDKs generally provide building blocks while callers remain responsible for starting processes, deploying workers, connecting queues, and saving state. Omnara moves those runtime responsibilities back to the server.
There is a trade-off. There is less code, but also more platform dependency. Callers begin relying on its API, event format, and deployment model.
Sandboxes, Secrets, and RBAC Are the Real Hurdles
Omnara gives Agents a sandbox in which they can execute commands and handles secrets, permissions, and RBAC.
Together, these capabilities bring it closer to production requirements than many Agent demos.
Once an Agent can run commands, the problem is no longer limited to whether its answer is correct. It might read a repository, call an internal API, modify files, or treat content from an external web page as an instruction.
A reasonable runtime needs to answer at least four questions:
- Which commands can the Agent execute?
- In which isolated environment does it execute them?
- Which secrets can it use, and under what restrictions?
- Which users or services can send messages, view logs, and cancel jobs?
RBAC addresses the last category of questions. Secrets address the third. Sandboxes constrain the blast radius of the second.
The counterintuitive part is that Agent infrastructure is often harder than inference. Answer quality can improve by changing models, tuning prompts, and adding evaluations. Command isolation, credential exposure, and excessive permissions generally cannot be fixed with a single prompt.
The Omnara team initially built mobile applications for remotely controlling Claude Code and Codex. The project summary also notes that its early harness ran on a laptop.
That experience helps explain why the team focused on the execution environment rather than building another chat interface.
Caution is still warranted. The project summary claims sandboxing, permission, and RBAC capabilities, but the available material does not disclose its isolation implementation, audit granularity, or production SLA. Whether it is suitable for highly sensitive workloads requires reviewing the source code, deployment documentation, and independent security testing.
Postgres Enables Resumption After Restarts
The project summary states that each Agent's state is stored in Postgres. Agents can therefore recover across service restarts and incur no running costs while idle.
This is the most practical difference between Omnara and many in-process Agents.
If Agent state exists only in memory, a worker restart, rolling container deployment, or machine failure interrupts the task. Preserving state usually requires adding a database and recovery logic.
Omnara uses Postgres as its persistence layer. Jobs can pause and resume, and teams do not have to keep paying for model or compute resources when no jobs are running.
However, using Postgres for state does not mean Postgres alone provides a complete task queue.
They solve different problems:
- Agent state answers, “How far has the job progressed?”
- A task queue answers, “Which worker will claim the next job?”
- Leases and heartbeats answer, “How should a job be retried after a worker crashes?”
- Idempotency keys answer, “How can a resent message avoid being executed twice?”
A production system may still need Redis, RabbitMQ, SQS, or another queueing component. Omnara's key design choice is to base Agent continuity on Postgres instead of requiring clients to store entire conversations and execution contexts themselves.
“Zero cost while idle” also requires a precise interpretation. The project summary uses this phrase, but it more likely means there is no ongoing compute expense, not that storage, database, and control-plane costs disappear.
Open-Source Alternatives Must Pass the Operations Test
Compared with Claude Managed Agents, Omnara's appeal is clear: it offers less platform lock-in and allows state and execution environments to remain closer to a team's own infrastructure.
But an open-source alternative does not automatically reduce the bill simply because a managed API can be downloaded and run locally.
Teams deploying Omnara still have to:
- Provision and maintain Postgres.
- Monitor Agent Loops, sandboxes, and event streams.
- Track security patches and dependency upgrades.
- Design backup, disaster recovery, and failure recovery processes.
- Validate secrets, RBAC, and logging policies.
This is what a Managed Agent platform is really selling: not a single model request, but the assurance that someone else will keep the system running.
Omnara removes platform lock-in and some integration work. Whether it saves money depends on whether the team already has Postgres, a container platform, monitoring, and security expertise in place.
For an individual developer, the hosted version may be the simpler choice. For a platform team that needs custom permissions, retains data sovereignty, and already operates Kubernetes and databases, an open-source Runtime may offer practical advantages.
My assessment is that teams considering a switch from Claude Managed Agents to Omnara need to answer at least one question: who will respond to the alert and recover jobs when a worker crashes at 3 a.m.? If the answer is the existing platform team, the migration may deliver less value than expected.
Editorial Take
Omnara is worth examining not only because it trended on Hacker News, but because it makes the boundaries of an Agent Runtime explicit. Models can be replaced, but task state, permission boundaries, and execution environments determine whether an Agent can keep working over time. When selecting a platform, teams should compare recovery after failures, credential isolation, and accountability for jobs rather than the quality of a single response. These issues have a direct impact on production incidents and operating costs.
My expectation is more cautious: Omnara is unlikely to replace Claude Managed Agents in the short term. It is more likely to attract platform teams that require self-hosting, custom permissions, and data sovereignty, while individual developers continue to choose the hosted version. Unlike earlier Agent SDKs, Omnara is competing for control of the runtime rather than merely offering a set of development abstractions. The available material does not provide enough evidence to assess the strength of its isolation, Postgres concurrency model, or behavior under large-scale event streaming, so those conclusions will depend on source code review and load testing.