Skip to content

← Learning paths / Build and ship your first app

Lesson 3 of 9

Follow a ticket from request to deploy

How the software factory runs a ticket with one agent from your request to a merged, deployed change, and how to read status, cancel, and retry.

The software factory at build.chipp.ai is an autonomous development system. You describe what you want as a ticket; an AI agent explores your code, writes the change in an isolated sandbox against your project’s real repository, checks it against your acceptance criteria, and, once your project’s checks pass, merges and deploys it to your live app. You watch the whole thing happen live and stay in control of budget and approvals.

ℹ️

This guide covers the software factory: the ticket-driven autonomous development system. It is separate from the Alchemist copilot, which is the chat assistant inside the Chipp app builder; see The Alchemist Copilot.

Dispatching a ticket

A ticket is a title plus a description of what you want: a feature, a fix, a refactor, or an investigation. The better the description states the goal and how you would judge it done, the better the result. You can dispatch one:

  • From the dashboard at build.chipp.ai, with + New ticket on your project’s Tickets page.
  • From a connected Chipp agent: any Chipp app connected to your software factory workspace can dispatch tickets mid-conversation, so “file a ticket to fix that” works from chat. This includes your project’s own agent in Slack. See Your Project’s Agent in Slack.
  • Programmatically over MCP: the platform exposes dispatch_ticket, list_tickets, get_ticket, and related tools to any MCP client authenticated with your tenant API key. See the Software Factory Tickets MCP guide for connection instructions.

Tickets get a reference like PROJ-42 and show up immediately in the Tickets list.

How a ticket runs

Every ticket runs with one agent in one sandbox, from start to finish. The agent keeps the whole ticket in one working session, so nothing is lost between steps and you pay for one context, not several.

  1. Explore. For anything beyond a trivial change, the agent first sends a few read-only helpers into your codebase in parallel: where the code lives, which patterns to reuse, which callers and tests are affected. Nothing changes in this step.
  2. Write the acceptance checklist. The agent turns your ticket’s acceptance criteria (a list under “Acceptance criteria”, “Definition of done”, “Done when”, or similar) into a checklist. If your ticket has no such list, the agent writes one first.
  3. Implement. The agent writes the change on the ticket’s own git branch, commits as it goes, and takes screenshots of screens it changed.
  4. Report. The agent reports each checklist item as PASS, FAIL, or UNVERIFIED, with its evidence.
  5. Land. The platform runs your project’s checks on the branch. If they fail, the same agent fixes the problem and tries again. When they pass, the branch merges into your base branch.
  6. Deploy and verify. The merge deploys through your normal pipeline, and the platform confirms the deploy succeeded. When a ticket has checks that only make sense on the live app, a post-deploy check runs them against your deployed app.

Tickets that change data in your live database instead of code follow the same shape: the agent proposes, applies, and verifies the data change, and there is no code to merge. See Data and Script Operations.

This replaces the earlier multi-agent design, where separate planning, review, security, and verification agents each handled part of a ticket. If older material describes those separate steps, it no longer reflects how tickets run.

Watch it, or take over

While a ticket runs, Open in Builder on the ticket page (shown to the person who filed the ticket, when they can edit the project) opens the agent’s conversation and a live preview of its sandbox. You cannot type while the agent is working; Take control pauses the ticket so you can continue the work yourself.

Reading a ticket’s progress

The ticket detail page shows the ticket’s steps (the agent’s work, then land and deploy checks), a session audit of every agent turn, each step’s report, and running cost against the ticket’s budget. Each step carries a status as it executes:

  • queued: waiting for its turn (either it has unmet dependencies, or a worker has not picked it up yet).
  • running: actively executing.
  • awaiting input: paused on a question for you. See Answering Agent Questions for what these look like and how to reply.
  • succeeded / failed / skipped / cancelled: terminal states; nothing more happens to that step.
  • blocked: waiting on an earlier step, or on another ticket if this ticket declared a dependency.

Click any step to open its detail drawer: the model it ran on, its duration, its cost, and its report.

Stalled or failed steps

A step that sits in queued for a long time is usually waiting for capacity, not stuck; the page keeps polling and moves it to running on its own. A step in failed status has a report attached explaining what went wrong, visible in its detail drawer, and the steps after it show as blocked until you act. There is no per-step retry button: retry the whole ticket (see below), which resumes from the last good checkpoint rather than starting over.

Landing and deploying

When the agent finishes and your project’s checks pass, the land step merges the ticket’s branch into your project’s base branch. Base-branch changes (yours and every other in-flight ticket’s) are serialized through a merge lease, so two tickets landing at once cannot race each other or silently drop one of them. Landing triggers a deploy through your project’s normal pipeline exactly the way pushing to the branch yourself would; the deploy appears in your project’s Releases tab, and a deploy check confirms the outcome before the ticket is marked done.

If a land step never completes, the work is not lost, it stays on the ticket’s own branch. See Rescuing a Stuck Ticket to fetch it and land it yourself.

If the deploy itself fails (a build error or a rollout crash, as opposed to the ticket’s own work), that is a deploy problem, not a ticket problem: the platform automatically retries a deploy that looks transient up to a capped number of attempts, and the ticket page also offers a self-serve “Retry deployment” action on a failed deploy so you do not have to leave the ticket to re-trigger it.

Cancel semantics

You can cancel a ticket from the ticket page, or over MCP (cancel_ticket), whenever it is queued, running, blocked, blocked on credits, awaiting input, or awaiting a deploy to finish. Cancelling stops further work: no new step starts, and the running agent is stopped. It does not undo anything: whatever has already landed is a normal git commit on your base branch, inspectable and revertable like any commit, and any deploy already in flight from a prior land proceeds independently under the platform’s own rollout monitoring. A cancelled ticket can be retried later.

Retry semantics

Retrying a ticket (the Resume button on the ticket page, or the equivalent MCP action) defaults to resuming in place: the platform checks for durable checkpoint state (a pushed commit on the ticket’s branch, or a step that already succeeded) and, when it finds one, continues the same ticket from there instead of throwing away that work. This is why most retries are cheap and fast.

If the approach itself was the problem, Start over is an explicit, separate action: it abandons any committed work on that ticket and creates a brand-new ticket instead. Use it when the underlying approach needs to change, not just an individual step.

Deploy-level retries are a separate concept from ticket retries, see “Landing and deploying” above: they only re-run a failed build or rollout for a commit that already landed, and never re-open the ticket that produced it.

Budgets and approvals

Every ticket runs under a budget. If a ticket cannot fit its budget, the ticket does not silently fail or silently overspend: it parks and asks you to approve the higher amount, and only proceeds once you do. Rejecting closes the ticket with the decision recorded. For how cost estimates are produced, how per-ticket and per-project spend is tracked, and how to query costs over MCP, see Software Factory Budgets and Costs.

Your project can also receive ticket proposals from other projects’ agents via cross-project proposal links. Proposals land in the same Approvals lane and require the same explicit decision before any work starts. See Cross-Project Proposals for how to file proposals to other projects (including the built-in Chipp platform support channel) and how decisions and outcomes are reported back to the proposing side.

Some tickets need to change something in your live database rather than your code. These are called data operations, and they always require an explicit approval on the exact SQL or script text before anything touches your database. For the full lifecycle (propose, approval card, dry-run vs execute mode, reading run output, retry/decline semantics), see Data and Script Operations.

Reviewing the work

  • Work Review collects completed tickets’ diffs and reports for you to inspect. See Software Factory Work Review for what it shows and your options when a result is not what you wanted.
  • Step reports and the full agent-turn audit trail are covered in Software Factory Reports and Audit.
  • Failed or blocked tickets say why, with the failing step’s report attached, and can be retried (see “Retry semantics” above).

When you’d rather do it by hand

Some changes are easier to just make yourself. Your project’s repository is yours: clone it, edit in Claude Code or Cursor, and push. Pushes deploy through the same pipeline as agent merges and are coordinated with in-flight agent work. See Software Factory: Clone Your App’s Code and Develop Locally, which also covers debugging your deployed app (logs and read-only database queries) straight from your editor.

FAQ

Do agents and my own pushes conflict? No. Base-branch changes are serialized through a merge lease, and deployments are deduplicated by commit, so the same change never ships twice and nothing races.

Can a ticket depend on another ticket? Yes. Tickets can declare dependencies and larger scopes fan out into multiple coordinated tickets; see Software Factory Ticket Dependencies for how depends_on and blocking work.

What does a ticket cost? Cost is metered per ticket from actual model and sandbox usage and shown live on the ticket detail page, with the budget ceiling alongside it. See Software Factory Budgets and Costs for the full picture.

What if a ticket goes wrong? Cancel it any time from the ticket page or over MCP (cancel_ticket); see “Cancel semantics” above for exactly what stops and what stays. Nothing lands on your app until the land step completes, and everything that does land is a git commit you can inspect or revert.

Next steps

New to the software factory? Start with Getting Started, then come back here. From this guide, the natural path is Budgets and Costs → Ticket Dependencies → Work Review.