The demo wins the deal.
Delivery eats the margin.
Agencies, AI service teams, and managed AI providers use Runtype as the AI product runtime behind every client build: one layer that turns a prototype into a product you can deliver, operate, and sell again.
Every client project rebuilds the same runtime.
Prototyping is no longer the hard part. Claude, Cursor, and a weekend get you a demo that wins the room. Then the client signs, and you start paying for it: schedules, delivery channels, approvals, state, retries, logs. None of it is billable strategy. All of it decides your margin.
Recurring schedules and triggers
Delivery into Slack and email
Client approval before anything ships
Structured outputs and branded PDFs
Logs your team can debug from
State that survives the session
Where the demo dies on the way to delivery.
The gap between a working prototype and a client-ready capability is not one missing feature. It is an operating layer, and rebuilding it per client is how AI engagements quietly go underwater.
The demo
One happy path, your best person driving, output pasted into a deck. Impressive, and it should be. Demos are cheap now. So are your competitor’s.
The pilot
The client wants it in their Slack, running every Monday morning, with their ops lead approving outputs before anything goes out. Now you are writing infrastructure nobody scoped.
The retainer
Six clients later you are an infrastructure company with six bespoke stacks, on call for all of them. The margin you modeled is gone.
The delivery layer, already built.
Runtype’s primitives map one-to-one to the things clients actually pay for, and to the things that currently eat your delivery hours.
Deliverables you can resell
Flows
Encode the engagement as a flow: deterministic steps, structured outputs, error handling built in. The second client gets the same architecture with different configuration instead of a second codebase.
Meet clients in their channels
Surfaces
Chat, Slack, email, API, MCP, SMS, schedule. Shipping into a new client’s stack is a configuration change. Add a channel without touching the logic.
Retainer-grade recurring work
Schedules
Weekly briefings, daily digests, monthly reports run themselves on a cron you set once. Recurring deliverables are what justify recurring invoices.
Client sign-off without email threads
Approvals
Human approval steps live inside the workflow. The client’s reviewer approves in Slack or email, the run continues, and the sign-off is on the record.
Client-scoped state and artifacts
Records
Each client’s data, memory, and generated artifacts live in records scoped to that engagement. Context compounds across runs instead of resetting every session.
Proof of quality at handoff
Evals + logs
Run evals before you change a prompt or model, and hand the client execution logs instead of assurances. Quality becomes something you demonstrate, not something you assert.
Four products you could package this quarter.
Each of these is one client workflow, productized. Sell it to the next client with configuration changes instead of rebuilds.
Client intake and proposal agent
Qualifies inbound briefs, drafts the proposal from your templates and past engagements, and routes it to a partner for approval before it leaves the building.
Branded report and PDF generator
Turns raw data into client-branded reports and PDFs on demand or on schedule: structured outputs in, polished deliverables out.
Weekly executive briefing
A scheduled agent that gathers performance data, drafts the narrative, and lands a briefing in the client’s inbox every Monday. The retainer that renews itself.
Content engine with approval gates
Generates campaign and commerce content against brand guidelines, with the client’s marketing lead approving each batch before publication.
Custom builds scale your costs. Products scale your margin.
The economics of agency AI work come down to one question: does the second client cost as much as the first?
Common questions
Can we white-label what we deliver?
Yes. The embeddable chat widget is fully themeable to the client’s brand, and Slack, email, and API surfaces run inside the client’s own channels. Your client sees your product, not ours.
Who owns the client’s data and keys?
You control the workspace. Client credentials are stored encrypted and injected at execution time; the model never sees them. Bring your own provider keys or start on platform keys.
What happens when models change?
Multi-provider routing means you can swap models per step without re-architecting. Evals let you regression-test the client’s workflows before the change ships, so an upgrade never becomes an incident.
Do we have to migrate clients off n8n or Zapier?
No. Keep automation where it already works. Runtype is for the capabilities clients touch and pay for: agents, surfaces, approvals, recurring deliverables. Its tools can call anything with an API, including your existing automations.