OuterEden
PTBook a demo

Live demoOuterEden · Agentic Native Platform

Say it.Your platform does it.

Declare your tools once. OuterEden runs the agent your users talk to, by voice or chat, and makes the calls for them. Every call is checked before it runs: it must exist in your declaration, every ID it names must have come from your system, and nothing that moves money runs without a yes.

Book a demoSee the integration

Interactive simulation. Three products built by OuterEden's customers — a store, a clinic and a bank — declare their own API, and OuterEden bundles each one into an agent their own clients can talk to. A client asks by voice; OuterEden makes the function calls, asks for a yes before anything that changes the client's account, and blocks hallucinated calls before they reach the product. The conversation is readable text, and you can type your own request.

OuterEdennot connected
  1. 01Declare
  2. 02Bundle
  3. 03Talk
integration.tsnew file
export const integration = defineIntegration({
  brief: "Aurora's catalog, cart and checkout.",
  refs: R, tools, goal,
});

$ npm run dev

✓ declaration · 12 tools

✓ bundling for chat + voice…

Executed0
Verified0
Blocked0
Hallucinations executed0
The client asks

02How it works

Declare once. Operate by voice.

You don't build an agent. You declare what your product can already do — each call, its arguments, and what it costs if it goes wrong — and OuterEden turns that into one your users can talk to.

  1. 01

    What your users click.

    Buttons, forms, menus. Every one of them is an API call underneath.

  2. 02

    What you declare.

    One file. Each call, its arguments, and what kind of effect it has: a lookup, a reversible hold, or something that moves money and cannot be taken back.

  3. 03

    What the agent gets.

    An agent OuterEden hosts for your users; chat and voice are the surfaces it will run on. Your declaration says what each call needs and what it produces, so the agent can't skip a step or invent an ID, and OuterEden checks every call against it before your product sees it.

03Verification

Hallucinations never reach your platform.

Models guess. OuterEden doesn't let a guess run. Every call the agent proposes is checked against your declared API before it executes, and anything that moves money waits for your user's yes. What fails is stopped with the reason, and the agent replans.

Animated stream of proposed actions. Valid ones pass the OuterEden verification gate and execute. Invented actions and IDs that don't exist are stopped at the gate. A wrong argument type is refused by your endpoint before your handler runs, and a call that breaks a precondition by your own system; the agent then replans.
Proposed0
Executed0
Blocked0
Hallucinations executed0
  1. 01

    Exists

    The action is in your graph. Invented actions are refused.

    payments.payAll()✕ not in graph

  2. 02

    Types

    Arguments are checked against the types you declared before your code runs. Nothing is coerced.

    cart.add(sku, "two")✕ qty: expected int

  3. 03

    References

    Every ID resolves to a real record, or the call stops.

    cart.add("SKU-9999", 1)✕ no such product

  4. 04

    State

    Your own system checks preconditions on live data, right before it runs. A refusal comes back typed, and the agent replans.

    book("dr_helena", "08:00")✕ slot taken

  5. 05

    Consent

    Anything that moves money waits for a yes, and the amount on the card comes from your system, never from the model.

    payments.pay(…)◷ waits for yes

04Scale

Complexity scales. Hallucinations don't.

One step or ten thousand, every step passes the same verification. In an unverified agent, hallucinated actions pile up with every step. With OuterEden, the number that reaches your platform stays at zero.

ready
Steps executed0of 1,000
Hallucinations blocked0caught, replanned, then run correctly
Hallucinated actions executed
Unverified agent0
With OuterEden0

Illustrative simulation. Assumes 2% of the steps a model proposes are hallucinated: invented actions, wrong types, IDs that don't exist.

05Integrate

Describe. Declare. Mount.

One dependency and one endpoint. You declare your tools and mount a route; OuterEden runs the agent and calls you. No agent loop to host. No model key to hold.

tools.tsSDK in preview
export const capture = defineTool({
  name: "checkout.capture",
  effect: "commit",
  idem: true,
  args: { authId: R.authId },
  emits: [R.orderId],
  binds: { from: R.authId, into: R.orderId, facts: ["/total"] },
  async handler({ authId }, ctx) {
    const order = await shop.capture(authId.auth_id, ctx.idemKey);
    return ctx.ok({}, [ctx.emit(R.orderId, order)]);
  },
});
terminal
  1. ✓ declaration validated · 12 tools
  2. ✓ effects typed · money-moving calls flagged
  3. ✓ endpoint mounted · signed calls only
  4. ✓ agent ready
  5. live on shop.aurora.example · your clients can talk to it

The SDK is in private preview: we hand it to you on the call, and the declaration package goes public with the release.

  1. 01

    Describe your tools

    In plain language: what your product does, and for whom. That's the agent's brief.

  2. 02

    Declare your API

    Declare each call and write the handler behind it, in your own code on your own machine. Say which ones move money.

  3. 03

    Mount the endpoint

    Every call the agent makes arrives as a signed request your own code answers, for the user your own login issued a token to.

06Versus API-first

An agent API is a project. OuterEden is a declaration.

API-first agent platforms hand you an endpoint. Everything between that endpoint and your product is still yours to build, and to keep working.

API-first agent platformnot started
  1. Design an endpoint for every action
  2. Write and maintain tool schemas
  3. Build and host the agent loop
  4. Map model output onto your API
  5. Add validation and guardrails
  6. Handle retries and partial failures
  7. Keep all of it in sync with your product
OuterEdennot started
  1. Declare your API, mount the endpoint

Agent-native

  • The agent, hosted by us
  • Typed actions from your declaration
  • Every call checked before it runs
  • IDs come from your system, never the model
  • Money moves only after a yes

Ready

Let your users talk to it.

Bring your API. We'll declare it with you and run your hardest workflow by voice, live.

The SDK is in private preview: we hand it to you on the call, and the declaration package goes public with the release.

Book a demoSee the integration