Agents & the control plane

Typillar runs two agents, and they do not stand in line. Each has its own tab and its own job: the build agent writes code, the plan agent writes tickets. Nothing is routed from one to the other. This page explains who is actually doing the work.

The build agent

The build agent lives in the Build tab, and it is the one that touches your code. What you type there becomes a ticket — your words, kept verbatim, as the ticket’s description — and the agent starts building against it immediately. Nothing rewrites your request first, and no other agent reviews it on the way.

It:

• writes the code for the change (see The stack),
• turns on the capabilities it needs — a database, file storage, a scheduled trigger — rather than asking you to toggle them,
• asks you in the thread when a decision is genuinely yours, and pauses until you answer,
• keeps README.md true as what the project does changes,
• commits the source to your GitHub repository,
• closes the ticket with the decisions it made.

It does not deploy on its own. Going live is your call — see Deploys & rollback.

The plan agent

The plan agent lives in the Plan tab, and it never writes code. It is a brainstorm partner: you talk through a direction, and it turns that direction into a tree of tickets — a goal, with the features, fixes, and chores that serve it nested underneath. It also keeps README.md current, which is how a decision you make while planning survives into every later build.

Nothing builds and nothing deploys from the Plan tab. A ticket only becomes code when you send it to Build. See The Plan tab.

The Plan tab is optional. Typing a change straight into the Build thread is the normal path; planning is for work with more than one moving part.

The control plane

The control plane is the part Typillar owns and runs: the orchestration that dispatches the agents, relays the questions they ask you, provisions what a build turns on, and records what happened. It coordinates the work but does not host your project or store your data — those live in your accounts. See What you own.

Think of the control plane as the office and the agents as the staff. The office schedules and supervises; the actual project is built and kept at your address.

Where inference happens

The agents reason and write code using a model — and that model runs on your side, on your own Cloudflare account. The control plane decides what to do; your infrastructure provides the thinking and the running. See Your models and Zero inference on our servers.

The part Typillar uniquely owns

Plenty of tools cover one slice — a tracker for tickets, an assistant for code, a platform for hosting. Typillar owns the hand-offs between them: a request becomes a ticket becomes committed code becomes a deployment becomes history, without you stitching the tools together. Owning the whole loop is what lets a single sentence end at a live URL.