How Typillar works

Typillar turns a conversation into a project. You describe what you want; agents build it, ask you when a real decision comes up, and ship it to your infrastructure — and every step is recorded, so the project has a memory and stays reversible. Every project, from a one-page site to a multi-feature app, moves through the same loop.

The loop

1. You describe an idea. A sentence is enough: “A waitlist page where people leave their email.” There’s no ticket format to learn.
2. It builds. You talk and it builds — there’s no approval button to click first. The build agent writes the code, turns on what the feature needs (a database, a scheduled trigger) on your Cloudflare account, commits the source to your GitHub repository if you’ve connected one, and gives you a preview to click through.
3. It asks you when it must. When a choice is genuinely yours to make, the agent asks in the thread and waits for your answer, then picks up exactly where it left off. It doesn’t guess at the decisions that matter and it doesn’t stall on the ones that don’t.
4. You keep talking to shape it. The thread is a conversation about this app — a follow-up refines the same project, it doesn’t start a new one. Ask for a change and the next build carries the history forward.
5. You ship — and it stays reversible. Say “deploy it” (or use the Ship button) and Typillar provisions the resources it needs in your Cloudflare account and puts it live at a real production URL. The deployment can be rolled back, and with GitHub connected the full code history is retained, so any prior version can be restored.

What that looks like

you        "A waitlist page where people leave their email"
agent      building… wrote index.html and App.svelte, provisioned a D1 database
agent      "Show how many people have joined, or keep the
            count private?"                       ← asks only when it matters
you        "show the count"
you        "deploy it"
deploy     → https://waitlist.acme.workers.dev
status     production · rollback ready · pushed to github.com/acme/waitlist

Where each part runs

Stage	Runs on
Planning & orchestration	Typillar’s control plane (the agent system)
Code generation (inference)	Your Cloudflare account — Workers AI, or a frontier model on your Cloudflare billing
Build output (the app)	Your Cloudflare account — Workers, D1, Durable Objects
Source of truth	Your GitHub repository, once connected

Typillar coordinates; your infrastructure executes and stores. That separation is the whole point — see What you own for the full split, and The build loop for a closer look at how a request becomes shipped code.

Where you stay in control

Control doesn’t come from a gate you have to clear before every build — it comes from staying in the conversation:

• It asks before the decisions that are yours. The unknowns that would change the project come back to you as a question, not a guess.
• Nothing ships until you say so. A build runs in your account; it goes to a live URL when you ask it to.
• Everything is reversible. Any live deployment can be rolled back. And with GitHub connected, every change is a commit, so you can restore the code to any earlier version — you react to what’s live rather than gate what isn’t.
• The connections are yours. Cloudflare and GitHub access is granted on their own screens and revocable anytime, and Typillar never touches a resource in your Cloudflare account that it didn’t create — see Permissions & access.

Why a conversation, not a chat

A chat answers and forgets. This loop accumulates: every build becomes committed code and a recorded deployment, so the project has a memory and a history. That’s what lets the agents reason about what already exists and let you undo with confidence.

Next

Run it yourself in the Quickstart, or see what your app can do once it’s live.