Running Tethra and SmallERP today

Put agents inside
your product,
in one call.

AgentOS runs the model, the tools, the memory, and the approvals behind every agent turn. Your product keeps its own data and its own UI.

Talk to usSee how it works

Software and SaaS teams that want agents in their product without building the engine.

Before an agent ever ships

Most teams build the engine before they build the agent.

A reasoning loop and a memory store

Every agent needs a loop that plans, calls tools, and checks its own work, plus a vector store that remembers per tenant and per project. Most teams build both from scratch before an agent ever ships.

A tool catalog with scoping

Every action an agent can take needs a catalog, a refresh cycle, and scoping so one customer's tools never leak into another customer's turn.

Approval gates, usage accounting, tenancy

Risky actions need a human gate. Every turn needs a cost number. Every key needs to map to exactly one tenant. None of that is your product logic.

How it works

Three steps between your product and a working agent.

No new infrastructure to run. Connect, register, and call.

01

Connect with a DSN.

One key per product: agentos://key@host/tenant. It authenticates every call, and it is the only credential you need to start.

02

Register your agents and your tools.

Give each agent a soul and a model tier, then point AgentOS at your MCP endpoint. Your own systems become agent tools.

03

Call RunAgentTurn.

One call runs the model, the tools, and the memory, and streams the reply straight into your UI.

Talk to us

What you get

The engine behind every agent turn.

Model, tools, memory, and approvals, all handled the same way for every product that runs on AgentOS.

Streamed turns

One call runs a full agent turn. RunAgentTurn and RunAgentTurnStream send back model started, tool calls, message bubbles, and done, with heartbeats that survive an idle tunnel.

model started
tool_call
bubble
done

Memory, per tenant and project

Every agent remembers, automatically. Long-term memory is isolated per tenant, agent, and project. Nothing for you to build or host.

Your tools, one MCP endpoint

Stand up one MCP endpoint and your own systems become agent tools. AgentOS refreshes the catalog and scopes every call to your tenant, agent, and customer.

Human approval before risky actions

Tool-level interrupts and a reactive engine stage a risky action as a pending Matter instead of letting a model execute it. A person approves before anything happens.

Usage and cost, streamed to your billing

Every turn streams a usage event with the cost, computed from the model that ran. Wire it straight into your own billing.

Skills and scratchpad

A per-project scratchpad and a skills menu, loaded on demand, keep prompts small without losing capability.

Coming soon

Bring your own provider and key

Choose your own model provider and key, per tenant. Keys stay encrypted in AgentOS, with no platform key fallback.

Evaluated against the live stack

Our eval suite runs against the real system, not mocks. It replaced a suite that scored 100% while four real bugs shipped.

Providers

Coming soon

Choose your provider and model, per tenant.

Keys stay encrypted in AgentOS. There is no platform key fallback, so a turn always runs on a key your tenant owns.

OpenRouterOpenAIAnthropicGoogle GeminiDeepSeekGroqAlibaba CloudxAIMistralTogether AIFireworks AI

Build it or use it

What changes when AgentOS runs the engine.

Build it yourself
AgentOS
Reasoning loop
You write and maintain a checkpointed loop that plans, calls tools, and checks its own work.
Already built. Runs every turn.
Long-term memory
You stand up a vector store and isolate it per tenant yourself.
Memory per tenant and per project, automatic.
Tool catalog
You build the refresh cycle and the tenant scoping.
One MCP endpoint. Refreshed and scoped for you.
Approval gates
You build a way to pause a risky action and ask a human.
Interrupts and Matters, built in.
Usage and cost
You compute and track cost per call yourself.
Streamed to your billing, per turn.
Tenancy
You hash, validate, and rotate keys yourself.
Key-based tenancy, checked on every call.

Pricing

Two ways to run on AgentOS.

For your product

Priced per engagement

We scope the connection to your product and price it together.

One call for a full agent turn: model, tools, memory, approvals
Your own MCP endpoint, refreshed and scoped for you
Human approval before risky actions
Usage and cost streamed to your billing
Talk to us
Coming soon

Bring your own keys

$99/ month per organization

For teams that want to run on their own provider account.

Bring your own OpenAI, DeepSeek, Groq, or other provider key
Pay your provider directly
Keys stay encrypted in AgentOS
Ask about early access

Questions

What teams ask before connecting a product.

Ready to put agents inside your product?

Tell us what your product needs and we'll show you what one RunAgentTurn call looks like for it.

Talk to us