For teams who already built their own

Your agent hallucinates. Oya makes it reliable and correct.

Oya compiles the plan once and runs it the same way every time, so the same job stays correct on run one and run ten thousand: state intact, real accounts, every step recorded.

Bring your agentTalk to the founders

Free credits to start, no card required · Usage-based after that, itemized per run

run #1180 · onboarding-agent · replayable
001trigger→new customer row, webhook from your CRM
002recall→prior state for this account: intact
003skill→provision_accounts() in an isolated sandbox
004check→no duplicate, identifiers byte-for-byte, email valid
005notify→welcome email sent, summary posted to Slack
plan compiled once · 5 nodes · executed in order
plan: compiled once, replayed exactlycost: $0.004every run recorded: inputs, tools called, output
What every run gives you
Same plan, executed the same wayState preserved across runsIsolated sandbox executionFailure alerts, not silence
Why Your Own Version Keeps Breaking

You can't prompt your way to correct.

The first version is a weekend project and it demos great. Then production shows up: state from last week, a rate-limited API, a retry that fires the same charge twice, a schema that changed under you. Every fix is another prompt or another patch of glue code, and none of it makes the next run deterministic. These are the jobs where wrong is expensive, and the ones Oya is built for.

promptingsame job, three attempts
run #1✗order drift: refund fires before the eligibility check runs
run #2✗state corruption: reads a stale balance, refunds $61.40 not $49.00
run #3✗duplicate: a retry re-runs the step, refund posts twice
three attempts, three different wrong answers
oya runtimesame job, one result
run #1✓eligibility checked, then refund $49.00
run #2✓state intact, refund $49.00
run #3✓a retry resumes the plan, refund posts once
every attempt, the same correct answer
Why Runtime, Not Prompting

Most agents fail on the third run.

The first run is a demo and it always looks good. Production is the thousandth run: state from last week, a rate-limited API, a half-finished job, a schema that changed under you. A bigger prompt and more glue code cannot guarantee that. A runtime can. The design behind that, and the measurements, are in the white paper.

plan compiled once
trigger→recall→skill→check→notify
executed in order · same plan every run · a retry resumes it, it does not start over
What a homegrown loop can't guarantee
  • State drifts between runs. An identifier comes back subtly different and the next run acts on the wrong record
  • Retries duplicate work. A timeout mid-run means the email goes twice and the charge posts twice
  • Failures are silent. The run ends, nothing errors, and the work simply did not happen
  • Nothing to audit or debug. A customer asks what happened, and the trail is scattered logs and a shrug
What the runtime gives you
  • The plan compiled once and replayed exactly, so the same job runs the same way instead of being re-guessed each time
  • Roughly 5× fewer tokens, since the plan is compiled once instead of re-feeding every tool result through the model on each step
  • State preserved across runs, so what the agent knew last time is what it knows this time
  • Isolated sandbox execution, so skill code runs somewhere real without touching your machines
  • Failures surface as failures, with an alert that says which step went wrong and why
  • Every run audited and traceable: replay it step by step, inputs, tools, output, and cost, so an audit is a lookup and a broken run is one you can debug
Vs Your Own Version

What the homegrown loop can't promise.

You can keep hardening the version you built, or you can move the guarantees into the runtime. The difference shows up on the runs you are not watching.

What happens when
Your own orchestration
Oya
The second run
Re-decided from scratch, and last week's state may or may not still be there
The plan from run one, replayed exactly, with state carried forward intact
A retry mid-run
Fires the step again, so the welcome email sends twice and the charge posts twice
Resumes the compiled plan where it stopped, and every step still runs exactly once
A step fails
The run ends, nothing errors, and the work simply did not happen
The step fails loudly, with an alert naming which step broke and why
Correctness
A bigger prompt and more guardrails, re-tuned after every miss
Non-conforming workflows fail at compile time, not in front of a customer
Credentials
Pasted into the prompt, one screenshot or one log line from a leak
Held by the platform, never placed in the model's context
Afterward
“What happened on that run?” is a shrug and a scan through scattered logs
Every run recorded: inputs, tools, output, and cost, replayable step by step
Where Agents Live

Your agent works where your team already does.

A correct agent still has to reach the systems the work runs through. Connect an account once and reuse it across every agent, with credentials held by the platform rather than pasted into a prompt.

SlackDiscordTelegramWhatsAppGmailGoogle CalendarGoogle SheetsGoogle DriveJiraClickUpWebhooksScheduled routines
Getting Started

Bring your agent in from where you already work.

You do not rebuild it here. Bring the prompt and glue code you run today through the tool you already have open, and Oya turns it into a deployed agent on the runtime. Three ways in, same result.

VIA CLAUDE

Connect Oya as a connector

In claude.ai, add Oya under Settings, Connectors, paste oya.ai/api/mcp, and authorize. Claude then creates the agent, adds its skills, connects its accounts, and deploys it, as tool calls you can watch.

VIA A CODING AGENT

Deploy from your editor

Point Claude Code, Cursor, or any MCP client at the same endpoint, or drive the oya CLI. Turn the agent you already maintain in code into a deployed one without leaving your workflow.

VIA THE BUILDER

Describe it in plain language

Or skip the tooling: say what the agent should do in the builder and it assembles one with the skills it needs, or start from a template and adapt it.

Start

Stop tuning prompts. Ship something correct.

Free credits to start and no card required, so it costs you an afternoon rather than a budget line. Bring the agent you built but do not fully trust yet, put it on Oya, and see whether it holds.

Bring your agentTalk to the founders
Running it at scale

Governed deployments

If your agents run under compliance requirements, or need to stay inside your own cloud with your own model endpoints, that is what Oya Enterprise is for.

See Oya Enterprise