Traces, not logs
Every step, its input, its output and how long it took, kept for 30 days. You instrument nothing. A step with a big response body is stored whole rather than trimmed to fit.
Customer-facing AI agents
Your customers talk to an agent. It talks to your systems.
Most support bots can write a nice reply. Yours has to look up the order, read the tone, apply the refund, and know when to fetch a person. You draw that flow once. We run it, remember what it needs between messages, and record every step.
From $19 a month · 7-day trial on Growth · Then you pay for what you run
agents / refund-triage
message
understand
orders.get
refundable
approve
auto-reply
run_8f2a41refund-triagerunning
- 02messages.loadmanaged · 6 turns12ms
- 03llm.calltool: orders.get412ms
- 04tool.httpGET /v1/orders/8821200 · 128ms
- 05conditiontotal > 200 → true1ms
- 06human.waitinbox · confirmpaused
- 07human.answerconfirm → yes2.1s
- 08agent.returnrefund applied · $2401.24s
The problem
The models got good. The wiring behind them didn't.
No support agent fails because the model can't write a sentence. It fails because it can't see the order. It can't remember yesterday. It can't be trusted with a refund. And when it gets something wrong, nobody can explain why.
74%
of deployed AI customer service agents are rolled back or shut down.
Sinch, 2026
7.8 mo
median slip on a first in-house agent build. Only 26% ship on time.
AgentCorps
$50K+
a year is where enterprise agent platforms start, and that's before a helpdesk seat.
Published 2026 vendor pricing
Building it yourself
On Mopus
Weeks of glue code wiring the model to your order, billing and CRM endpoints.
One step pointed at the endpoint you already run, with values passed in from earlier steps.
A conversation that forgets everything, or a store you built yourself so it wouldn't.
History kept for you under a session id, or read from your own API and mapped across.
An agent that either can't touch anything risky, or touches everything.
A step that stops the run, asks a person, and resumes with their answer.
A rolled-back launch, because nobody could say what the agent actually did.
Every step, input, output and timing recorded for 30 days. You instrument nothing.
The platform
The agent is the product. Everything else is what its steps reach for.
A model that can't look anything up, remember anything or act on anything is just a chat window. You build one flow. Inside it, a step can call your API, read memory, search your documents by meaning, or work out what a message actually said. None of it is a separate product you have to integrate.
01
The product
One canvas. Every kind of step.
An agent is a flow you draw. A step can ask a model, call your API, run JavaScript in a sandbox, branch on what came back, fan out in parallel, or stop and wait for a person. The model can call your endpoints as tools, pick a branch, or ask someone. Whatever comes back goes straight into the same conversation.
- Steps that call an API, run code, ask a model, or ask a person
- Conversation kept for you by session, or read from your own API
- A person answers by text, choice, yes/no, or a JSON Schema form
- CEL conditions on every edge, so branching reads off real values
agents / refund-triage6 steps
understandllm1 tool
refundableconditionCEL
parallel · both branches run
orders.getapi_call128ms
billing.fetchapi_call94ms
composerun_jssandbox
approvehuman_inputinbox
02
What a step reaches for
Memory, and documents it can search by meaning.
Unstructured buckets hold plain JSON by key. Session context, counters, whatever the run has to remember between messages. Semantic buckets hold text you search by meaning, built by hand or imported straight from your policy docs and help centre. A step reaches either one with an ordinary call.
- `{inc(1)}` is atomic, so concurrent writers add up instead of overwriting
- Import PDF, DOCX, CSV, Markdown, HTML or JSON up to 25 MB
- Crawl your own site, or add passages one at a time
- A webhook on every create, update and delete
buckets / support-sessionsses_9f3ab21
{ "session_id": "ses_9f3ab21", "customer_id": "cus_4c81", "attempts": "{inc(1)}", "resolved": false, "context": { "intent": "refund", "order_id": "8821" }, "ttl_seconds": 604800}attempts incremented atomically · no read-modify-write
webhook → POST https://api.yourapp.com/hooks/session
03
What a step reaches for
Know what the message actually said.
One call gives you the sentiment, the people and places it mentions, what it's actually about, the language it's written in, and every word tagged with its part of speech. Put it in front of the model to route on tone, or after it to check what came back.
- Sentiment, entities, key phrases, language and syntax, in one call
- They run together, and one failing doesn't sink the request
- Up to 5,000 bytes per call, so a long message is never a surprise
- Charged per character rather than per call
text-analysis / analyze66 chars
“Third time I've asked about order 8821. Still nothing from Dublin.”
Sentimentnegative91%
Entities
8821QUANTITYDublinLOCATIONThird timeQUANTITY
Key phrases
Third timeorder 8821
language enbilled 300 chars · 300 minimum
04
When there is no model
Chain the endpoints you already run into one call.
Not every problem needs a model. Point steps at your APIs, give each one an alias, pass values between them with `{alias.body.field}` templates, branch on what came back, and expose the whole chain as a single request. Run it now, queue it, or put it on a delay.
- An API call, and a condition that nests branches inside it
- Aliases become identifiers in templates and expressions
- One trigger token runs the whole chain
- Sub-second queueing, or a delay measured in days
orchestrators / customer-3605 calls · 421ms
POST/v1/auth/token84ms
GET/v1/customers/{input.id}131ms
GET/v1/orders?status=open186ms
POST/v1/refunds154ms
POST/v1/notify112ms
one trigger · POST /v1/orchestrators/customer-360/run
Everything else
The parts you only notice when they're missing.
None of this is an add-on or a different SKU. It's what you get by default.
Human in the loop
A run stops, an item appears in the Inbox, and the run resumes from that step with the answer.
Sandboxed JavaScript
QuickJS on WebAssembly. No filesystem, no network, no Node APIs, and hard caps on memory and time.
Now, queued, or later
The same flow can answer on the spot, go on a queue, or wait out a delay you can cancel.
One thread, many runs
One session id ties repeat runs together across agents and orchestrations, and filters the trace list.
Credentials that no endpoint will hand back
A stored API key is only ever described back to you: provider, label, masked preview. The real value leaves storage inside the execution path and nowhere else. Run tokens, bearer values and config constants are stripped from every error report before it leaves our account.
Executions
The part that keeps it switched on.
Agents get switched off because nobody can explain what they did. Open any run and you'll see the exact payload each step got, what it sent back, how long it took, and where it stopped.
- Retained
- 30 days
- Instrumentation
- None
- Grouped by
- Session
- Large payloads
- Kept whole
executions / run_8f2a41refund-triage
waiting on approval562ms elapsed
- 01messagestartrun-async · ses_9f3a2ms
- 02historyvariablemanaged · 6 turns12ms
- 03understandllm1 tool call412ms
- 04orders.getapi_call200 · 4.1kb128ms
- 05refundableconditiontotal > 200 → true1ms
- 06approvehuman_inputinbox · confirm
- 07replyrun_jsnot reached
Every row expands to the exact JSON that step received and returned.
How it works
Running against real traffic this afternoon.
There's no cluster to provision and no agent framework to learn. What's below is the whole of it.
- 01
Draw the conversation
Drop steps on a canvas and connect them. Conditions on the edges decide what runs. Containers fan work out in parallel.
- 02
Point it at your stack
Add your endpoints, a key for the model provider you use, and a bucket for whatever the conversation has to remember. Templates carry values from one step into the next.
- 03
Send it a message
One HTTP call from your app, your helpdesk or a webhook. Pass a session id and the thread continues where it left off.
API
One call from anything that speaks HTTP.
Everything the console does is an endpoint. Trigger a run from your backend, a cron, a webhook or a form. Wait for the reply, put it on a queue, or set it running later.
curl -X POST "https://api.mopus.co/v1/agents/$AGENT_ID/run-async?session_id=ses_9f3a" \
-H "Authorization: Bearer $MOPUS_AGENT_TOKEN" \
-H "Content-Type: application/json" \
-d '{ "message": "where is my order 8821?" }'
# 202 Accepted. The run is queued.
# Use /run-sync if you want to wait for the reply.30 daysOf full execution traces
90 daysOf conversation history kept
25 MBPer imported document
$19To start, per month
Pricing
A base plan, then you pay for what you run.
Every tier includes the whole product. Pick the one whose allowances match your traffic. You can move between them whenever you like.
Starter
$19/ month
For a first agent or two in production.
- 100K
- executions
- 200K
- bucket writes
- 400K
- bucket reads
- 20K
- passages added
- 30K
- semantic searches
- 250K
- text analysed
Growth
Most picked$79/ month
For a product that has found its users.
- 500K
- executions
- 1M
- bucket writes
- 2M
- bucket reads
- 100K
- passages added
- 150K
- semantic searches
- 1.5M
- text analysed
Scale
$299/ month
For steady, heavy traffic.
- 2.5M
- executions
- 5M
- bucket writes
- 10M
- bucket reads
- 500K
- passages added
- 750K
- semantic searches
- 7.5M
- text analysed
Past the allowance, on every plan
no tier discounts
- Executions
- $10/ 100K runs
- Bucket writes
- $5/ 100K calls
- Bucket reads
- $3/ 100K calls
- Passages added
- $20/ 100K passages
- Semantic searches
- $15/ 100K searches
- Text analysed
- $2.50/ 100K characters
Enterprise
Past Scale, or terms that don't fit on a pricing page.
Tell us the volume you're planning for and how your procurement works. You'll hear back from someone who works on the product rather than a sales development rep, and if we can't do what you need we'll say so in the first reply.
- Volume pricing past the Scale allowances
- Annual invoicing instead of a card every month
- Security questionnaires answered by the people who wrote the code
One execution covers a whole run, however many steps it takes. A run that waited for a person and picked up again is still one. Overage costs the same on every plan, so staying on a smaller one never costs you extra.
For comparison, published 2026 pricing for enterprise agent platforms starts around $50,000 a year. Per-resolution vendors charge about $0.99 every time the agent succeeds, on top of a helpdesk seat.
FAQ
The questions people actually ask.
Ship the agent, not the plumbing.
Draw the flow, point it at the APIs you already run, and have it answering real customers this afternoon.
From $19 a month · Billed monthly · Cancel any time from the billing page