White-Label AI Agents on Twig

You can now ship AI agents under your own brand on the Twig platform. Same primitives we run in production — the agent builder, voice agents, deep RAG, and the eval harness — exposed as a white-label layer so the thing your customers talk to is your product, not ours.

Create → Test → Launch

The loop is short on purpose. Define the agent in the builder, run it against the built-in eval suite until the behavior holds, and deploy. No separate test rig to stand up, no prompt-spelunking before you trust it in front of a customer. Most teams get a real agent live in days, not a quarter.

Live Demos

Why we built ASL (Agent Scripting Language)

The gap between an AI feature and an AI employee is not the model. A feature answers a question and forgets you. An employee owns a process: it runs a procedure end to end, carries state across the conversation, knows which actions it's permitted to take and under what conditions, and can be held to a measurable standard.

Sera, our front-desk agent, is the second kind. The thing that makes that possible is a layer we call Agent Scripting Language. Here's the part most "AI agent" products skip.

LLMs are great at language and bad at process

Hand a modern model a multi-step procedure in prose — greet, collect the required fields, qualify, then and only then take the action — and it'll comply most of the time. "Most of the time" is the failure. A few turns deep, the model skips a step, re-asks for a value it was already given, or invents a fact under pressure. Each of those is a probabilistic miss on an instruction buried in context, and the probability compounds with conversation length.

The two common workarounds both fail structurally:

The mega-prompt concatenates every instruction, edge case, and fact into one system prompt. It works until the prompt is a wall of mutually-contradicting rules where changing one behavior silently breaks three others. There's no isolation, so there's no safe edit.

The fully-autonomous agent hands the model a bag of tools and trusts it to sequence them. You get improvisation where you specified a procedure — correct ordering becomes an emergent property you're hoping for rather than a guarantee you hold.

A front desk or an SDR doesn't need improvisation in its process. It needs to run the same procedure every time, in language that still sounds human. The right split is: let the model do what it's genuinely good at — parsing the message, choosing the words — and take control flow away from it.

What ASL actually is

ASL is a declarative layer that separates what the agent says from what happens when. Instead of one monolithic prompt, an agent's job is expressed as small composable behaviors. Each behavior declares its own trigger condition and its own preconditions — what must already be true before it's allowed to run.

That dependency structure isn't decorative. We compile it: the needs relationships between behaviors are lowered into an explicit finite state machine — concrete states and transitions — rather than collapsed into a flat N-way classifier that asks the model "what should I do next?" on every turn. Control flow lives in the compiled FSM. The model is invoked inside a node to handle understanding and phrasing; it doesn't get a vote on whether a precondition is satisfied.

Two consequences fall out of that, and they're the whole point:

Guardrails are structural, not instructional. "Don't book before you have the required fields" isn't a polite sentence the model can drift past under load — it's a precondition on the transition into the booking state. The agent can't take an action whose preconditions aren't met, because there's no edge into that state. Escalation, tool calls, and writes are gated the same way.

Behavior is testable. Because the process is a defined artifact instead of latent prompt behavior, we can replay real conversations against a changed agent and assert it still does the right thing at each node. That's how we catch drift before it ships — a model swap or a one-line change that subtly degrades the agent gets flagged in eval instead of surfacing in production three weeks later when someone notices the booking rate dropped.

Vocabulary — the domain terms the agent has to hear and say correctly: service names, proper nouns, SKUs, the jargon a caller actually uses. You declare it once so ASR stops mangling "Cosán" or "BLW" and the model grounds on your words, not its priors.

Flows — the procedures an employee runs end to end: greet, collect, qualify, act. A flow is the FSM-shaped path through a job, and it's what makes the agent run the same sequence every time instead of improvising a new one each call.

Blocks — the composable unit a flow is built from. Each block declares its own trigger (when) and preconditions (needs) and the action it takes — so behavior is something you reason about and change one piece at a time, not a monolith you edit by holding your breath.

The ASL CoPilot

Authoring ASL is straightforward, but you shouldn't have to hand-write it. This week we're shipping the Twig ASL CoPilot — describe the job and it drafts the behaviors, triggers, and dependencies for you to review and refine.

Why it matters

AI features are easy to ship and easy to forget. AI employees have to show up and do the job the same way every time, and that reliability isn't something you prompt your way into — it has to be built. ASL is how we build it, and it's why Sera works a front desk instead of just answering a question.

More to come. For now, that's the architecture.