Agents as a service

The cloud platform for AI agents.

Orca is a cloud platform for running AI agents in production. Define an agent as a profile; Orca runs it with sandboxed execution, spend controls, persistent sessions, and streaming observability behind one API.

Start with $5 in free credits · Blog · For AI assistants

New accounts start with $5 in free credits. No card required.

Why Orca

Most of an agent feature is not the agent. Orca runs everything around it.

Each system is weeks of engineering, then maintenance forever. On Orca they are running before your first API call.

Run queue, retries, and session state
Sandbox isolation and provisioning
File permissions and workspace storage
Live event streaming into your app
Usage metering and spend caps
Rate limits, secrets, and egress control
Audit logging and RBAC
Traces, logs, and metrics
Keeping up with new models and SDKs

Your team ships features. We carry the pager.

How it works

Your product makes one API call. Orca handles everything between the request and the result.

Build: Describe an agent, not a codebase. Define the agent once in a profile: model, prompt, skills, sandbox. Every run uses it. Author profiles in the dashboard, no code needed. Attach skills, capabilities, and MCP servers.
Launch: One SDK call starts a run. Your backend, a script, or CI starts a run with one call. Orca handles queuing, retries, and lifecycle. Go, Python, and TypeScript SDKs (plus REST). Reusable agent profiles for any job.
Execute: Agents work in a locked room. Each run gets its own files, permissions, and network rules. Agents never touch your internal systems. Per-agent file permissions. Network egress protection built in.
Stream: Every event, live in your app. Tool calls, file writes, and progress stream back as they happen. Your users watch the agent work. Server-sent events, no polling. OpenTelemetry traces on every service.
Measure: Every run priced to the cent. Every run is priced the moment it finishes. Spend caps stop runaway agents before the bill. Per-run cost attribution. Fail-closed monthly spend caps.

Features

Queues, sandboxes, spend controls, observability. One platform, not five side projects.

Orchestrate: Run many agents as one system

Runs, sessions, pools, and workflows as API calls. One integration for Claude, Codex, and Vercel AI.

Ship agent features in a sprint, not a quarter. Queuing, retries, and run state are handled before you write a line. (Managed run lifecycle, Agent profiles, Persistent sessions)
Never get locked into one agent SDK. Claude, Codex, and Vercel AI behind one API. Switching is a config change. (Multi-SDK agents, Capability routing, MCP servers)
Put teams of agents on one problem. Fan a job out across a pool and collect the results deterministically. (Agent pools, Workflows, Skills, Memory bank)

Workspace: Real files, without the risk

Agents get a real filesystem. You keep control of every byte.

Real tools, zero reach into your systems. Agents read, write, and execute inside an isolated sandbox. (Virtual filesystem, Sandboxed execution, Policy-gated commands)
Permissions that act, not alert. Access is enforced the moment a file opens. Secrets stay out of prompts and logs. (Per-agent permissions, Scoped secrets, Environments)
Collaboration without side channels. Pooled agents hand work to each other through files you can inspect. (Pool-shared storage, Role-aware partitions)

Govern: Spend, access, and egress under control

Who can run what. How much it spends. Where its traffic goes.

Runaway agents stop at the gate, not on the invoice. Spend caps fail closed. When the budget is gone, new runs are refused. (Fail-closed spend caps, Rate limiting)
Walk into the security review prepared. RBAC, audit log, and network rules in the core platform. (Organizations and RBAC, Audit log, Egress guard)
A bill that traces back to specific runs. Every run is metered and priced. No end-of-month archaeology. (Usage metering, Credit wallet billing)

Observe: End-to-end observability, by default

Follow any run live, event by event. No black boxes.

Debug runs while they execute. Every tool call and token streams back over SSE the moment it happens. (Live run streams, SSE into your app)
Cost per feature without a spreadsheet. Usage rolls up per organization, per agent, and per run. (Usage dashboards, Per-run cost attribution)
Your observability stack, not another one. OpenTelemetry traces and logs into any OTLP sink you already run. (OpenTelemetry built in, Any OTLP sink)

Integrations

Your backend calls Orca like any other service. Live agent runs come back.

API. One documented API for runs, sessions, pools, and storage.
SDKs. First-party Go, Python, and TypeScript clients, generated from the spec.
MCP. Attach MCP servers to your agents, or drive Orca from MCP clients.

Machine-readable API spec: https://api.orcapods.ai/api/openapi.yaml

Deploy your way

Start in minutes on Orca Cloud, or run the same platform inside your own network. Your agent API stays the same.

We run it. You ship.

Launch on Orca Cloud with nothing to operate. Build, publish and scale from one place.

Live in minutes
Usage-based pricing
Scaling and upgrades handled for you

Your cloud. Your data.

Run the full Orca platform inside your network, backed by your keys, stores and controls.

Single-tenant in your VPC or data center
Your model keys, data stores and network policy
Tracing and logs in your observability stack

FAQ

Direct answers to the questions engineering teams ask first.

Is this only for coding agents?

No. A profile can define a support triager, a research analyst, an operations bot, or a code reviewer, and Orca runs them all the same way.

Why not just use the agent SDKs directly?

You can, until you need sessions that survive restarts, spend limits that hold, and storage agents cannot escape. Orca is the layer you would otherwise spend months building.

What about the managed agent platforms from model vendors?

Those run one vendor on one cloud. Orca runs Claude, Codex, and Vercel AI behind one API, with guardrails enforced where the work happens.

How does it fit into our existing app?

Like any backend dependency. Call the API, get a run ID, stream events into your own UI.

What does it cost to run?

Self-hosting is free; you pay your own infrastructure and model bills. Hosted, you top up a credit wallet and every run draws it down at posted rates.

How do you keep agents from doing damage?

Each agent works in a sandbox with enforced file permissions. Network rules block your internal systems, and spend caps fail closed.

Can we self-host it?

Yes, fully. Bring Postgres, S3-compatible storage, and your model keys; your data never leaves your cloud.

How do we see what agents are doing?

Live. Every tool call, file write, and token streams back while the run executes.

Is this ready for a security review?

It is built for one: RBAC, org-scoped tenancy, audit log, fail-closed spend caps, and egress rules. All in the core platform.

Built by you, or your agents

Paste one prompt into Claude Code, Cursor, or Codex. It installs the CLI, signs in with a device code, and follows the guide to build your first agent.

Onboard me to Orca, the cloud platform that runs AI agents. Work through https://docs.orcapods.ai/build-with-your-coding-agent, written for coding agents.

When `orca login` prints a one-time code, relay it and the URL so I can approve it on another device. Ask me what job I want done before writing anything. If a published kit already does it, add that instead of building from scratch.

Deploy now · Read the AI assistant guide