Build a Decagon-style support agent

~25 min TypeScript Python

What you’re building: Resolve tickets across chat and email, with handoff.

Primitives you’ll use: Sandbox, Agent and harness, Postgres, Deployment (Docker Host)

Agent prompt

Start with your coding agent

A few quick questions, then copy a prompt for any coding agent.

Who is it for?

Pick one to start. The rest adapts to it.

For my company Internal. One organization, a workspace per team, SSO. No billing. Build a product For customers. A workspace per customer, isolation, metering and billing.

What you're building

an AI customer-support agent that resolves tickets across channels Modelled on Decagon, by Decagon.

The agent resolves chat and email tickets by following your policies, calling your systems, and escalating with context.

Primitives you'll use: Sandbox · Agent and harness · Postgres · Deployment (App Engine)

Resolves tickets across channels
Follows company policies
Calls real systems
Escalates with context

Source: decagon.ai. Decagon is a trademark of its owner; this guide is not affiliated with or endorsed by them.

What you need on MIOSA

Each row is one thing to create before you start. The number matches the step that uses it.

Organization and API key Scopes every call; a workspace key is all a worker needs. miosa api-key create app-key --preset agent Docs
Sandbox The isolated Linux workspace the agent writes code and runs commands in. miosa create app-box --template nextjs --wait Docs
Postgres Managed relational data, injected as DATABASE_URL in the machine and in production. miosa api POST /databases -d '{"name":"app-db","engine":"postgresql"}' Docs
A workspace per customer Isolates each customer’s machines, deployments, and data as they onboard. miosa workspace create customer-1 Docs
Branding and white-label Your name and slug on previews, deployments, and the desktop; customers never see MIOSA. miosa org Docs
Usage metering and bill-to Usage per customer, and which account pays for new machines. miosa org bill Docs
Agent and harness Turns a prompt into work: pick the harness and model a run uses. miosa agent harnesses Docs
Deployment (App Engine) Publishes the app to an immutable, versioned URL with rollback. miosa deploy create --from-sandbox app-box --name app --wait Docs

Architecture

How it maps onto MIOSA

The agent that does the domain work -> agent runs (`miosa prompt`, client.runs) streaming events in a sandbox, with the tools it may call defined by you

Domain records and history -> managed Postgres (`DATABASE_URL`) for records, citations and an audit trail

Each customer is isolated -> a workspace per customer (`miosa workspace create`)

Human review and escalation -> agent approvals (`miosa agent approvals`) and a review queue in your product

Data and storage

Postgres is the system of record with an append-only audit table; nothing the agent decides exists only in a prompt.

Keep sources with every stored field so a human can check them.

Auth and tenancy

Your organization is the platform; customers never get a MIOSA account, they sign into YOUR product. One workspace per customer, created as they onboard, isolates their machines, runs and data.

miosa workspace create decagon-customer-1

Tag every machine and run with the customer id in `metadata`, and never query across customers. Meter usage per customer with GET /api/v1/usage and set who pays with PUT /api/v1/bill-to (/docs/platform/usage-and-billing).

Agent loop

Harness: OSA is MIOSA's own harness and works with any model provider you connect, including your own model.

Model: Anthropic (Claude). Calls use my own provider key (`miosa connections add models`); MIOSA platform keys are never used.

Sessions: one chat per project or conversation, so the agent keeps its context. The first `miosa prompt` on a sandbox uses `--new-chat` (a chat id is printed); every later turn passes `--chat <chat-id>`. `--reuse chat` keeps one new machine per chat so files persist.

Streaming: follow a run with `miosa run follow <run-id>` or client.runs.streamEvents(run.id), and steer or stop it with `miosa run steer` and `miosa run interrupt`.

The agent runs inside the sandbox with only the tools you defined. It proposes; your code enforces limits (refund caps, allowed recipients) so the model cannot talk its way past them.

Steps

Create the domain database.

miosa api POST /databases -d '{"name":"decagon-db","engine":"postgresql"}'

miosa db connection decagon-db

Check: Domain tables exist: customers, tickets, messages, actions.

Create the agent sandbox.
```
miosa create decagon-box --template agent-python --wait
```
Check: The sandbox is running with DATABASE_URL set.
Load the knowledge base (help center, policies) into a vector index so answers cite policy.
```
miosa api POST /databases -d '{"name":"decagon-knowledge","engine":"qdrant"}'
```
Check: A policy, document or article question retrieves the right passage.
Define the tools the agent may call on real systems (look up an order, refund within a limit, change an address) as narrow functions with typed arguments.
```
miosa prompt --sandbox decagon-box --harness osa --model <anthropic-model-id> --chat <chat-id> "Resolve ticket <id> using only the defined tools and the cited policy; escalate if unsure"
```
Check: The agent completes the case using only those tools.
Put a human in the loop where it matters: the agent proposes, a person approves anything irreversible or high-stakes, and low-confidence cases escalate with context.
```
miosa agent approvals
```
Check: A refund over the limit, a send, or a filing waits for approval.
Write an audit record for every agent action: who, what, inputs, outputs, and the run id.
```
miosa audit
```
Check: Any decision can be reconstructed from the audit trail.

Publish the agent API and the review UI.

miosa deploy create --from-sandbox decagon-box --name decagon --dir /workspace --port 3000 --run-command "npm start" --wait

Check: The public_url serves the review queue.

Limits and costs

Customer data is personal data: store only what the task needs, honour deletion requests, and keep an audit trail.

Keep tenant data separate: a workspace per customer, and every query filtered by tenant.

Set `--max-time` on runs and cap tool calls per case.

Prototype: keep it to one machine at the default size, skip replicas and custom hostnames you do not need, and delete everything when you are done.

Acceptance checks

The agent resolves a representative case end to end using only the defined tools.

A high-stakes action waited for human approval.

The audit trail reconstructs the decision.

Each customer is isolated in its own workspace and usage is metered against them.

Everything it created can be deleted with nothing left running.