---
title: "What is an executable ticket? — Dewline GmbH"
source: https://dewline.de/agentic-engineering/10-executable-tickets.html?via=md
language: en
updated: 2026-11-13
publisher: Dewline GmbH
---

Agentic Engineering, slide by slide · Article 10 · 2026

# What is an executable ticket?

An executable ticket is the unit of work in an Agentic Engineering Project. It contains everything an AI agent needs to complete a task on its own: the requirement, the acceptance criteria, tests with example data, and the rules for when the agent has to stop and ask a person. An executable ticket is small enough for one agent run, complete enough that the agent has nothing to ask, and cut so that a small model can execute it.

## What an executable ticket contains

1. **Requirement:** what has to be true afterwards.
2. **Acceptance criteria:** each one testable, none vague.
3. **Use cases and user stories:** who does what, in which order.
4. **Tests with example data:** readable by the business; whether they come before the code or alongside it depends on the variant.
5. **Mutations:** deliberate faults that prove the tests catch them.
6. **Manifest:** success criteria, stop points, and what the agent never decides alone.
7. **Named approver:** a role from the business, never the agent.

Whatever is missing, the agent has to ask for or guess. An executable ticket is designed so that it has to do neither.

## How an agent works through a ticket

1. **It picks the ticket up.** Everything it needs is in the ticket. None of it exists only in a colleague's head.
2. **It builds against the requirement and the tests.** They are the target, the code is the way there.
3. **It stops at stop points.** Where the manifest says a person decides, it puts the question forward and waits.
4. **It reports back** when it is finished, or when it meets a state the ticket did not foresee.

## Loop engineering: the loop inside the ticket

Within a run, the agent works in a loop: build, test, fix, test again, until all tests pass. We call the design of this loop loop engineering. It covers which checks run after each step, what feedback the agent gets from them, and when the loop ends. In an executable ticket this is defined. The tests determine when the agent is finished. The manifest determines when it stops and asks.

The more precise the tests, the fewer rounds the loop needs. Every round costs tokens. A well-cut ticket is therefore also a question of cost.

## Why mutations belong in it

A test that does not fail when the code is deliberately changed checks nothing. That is why an executable ticket contains mutations: small, targeted faults in the code, such as a reversed comparison or a missing condition. If a test does not fail on a mutation, it is too weak, and the ticket goes back before the agent works on it. In this way the tests check themselves wherever that is possible. In software engineering the method is called mutation testing.

Where a test cannot be checked this way, the project manifest sets out who decides: the documentation or a person.

## What people see

The business does not read test code. It sees test descriptions in plain language and a status per ticket, in the test-driven variant for example: specified, tests approved, in progress, tested, accepted. A ticket is small enough to estimate, to run in one go and to measure. Project management can therefore see at any time how far the project has got, measured in accepted tickets.

## How large a ticket is

The way the project is cut decides that. Tickets can contain sub-tickets. As a guideline:

- small enough for an agent to complete in one run,
- complete enough that it has nothing to ask on the way,
- narrow enough that a small model is sufficient.

With tickets cut for small models, token costs stay low and plannable, even if large models cost more in future. And small models can run in your In-House Cloud.

## Is an executable ticket test-driven or spec-driven?

An Agentic Engineering Project is agnostic about these paradigms. What suits the requirement, the project and the development is decided when the project is set up:

- **Test-driven development:** the tests come before the code. The agent builds until they pass.
- **Spec-driven development:** the specification is the central starting point. The tests are written alongside the development and run with it.
- **Another approach,** if it suits the project better.

This determines the variant of the executable tickets. They are always executable tickets with the same seven parts. Some are more test-heavy and closer to test-driven development, others are closer to spec-driven development. Whoever sets up the project chooses the variant. In the setup phase, skills ask for it: prepared instructions with which an agent helps to set up the project (article 3).

## Why "ticket"

In project management, tasks live in tickets. Anyone who runs projects already knows the unit. "Executable" means the ticket is complete enough to hand to an agent that works on it until it is finished or comes back with questions.

We used to call it an "executable contract", and the literature on spec-driven development speaks of specifications as "executable contracts". A contract, however, suggests something agreed between parties, a set of rules. With us, such rules live in the project manifest. The work itself lives in the ticket.

## Executable tickets and related terms

- **Specification in spec-driven development.** It describes a function from which code is generated. The executable ticket contains it and adds tests with mutations, stop points and an approver. Whether the specification or the tests are the starting point depends on the variant.
- **Test-driven development.** The tests are written before the code. This is one of the variants in which executable tickets are written.
- **User story.** It describes who wants what and why. In the executable ticket it is one of seven parts.
- **Asking a person.** In research on agentic software engineering, the agent calls on a person when something is ambiguous or involves trade-offs (Hassan et al. call these Consultation Request Packs). In an executable ticket it is defined in advance when that happens.
- **Agentic Engineering Project.** The framework in which executable tickets are written, worked through and accepted (article 3).

## Sources

- Ahmed E. Hassan et al., Agentic Software Engineering: Foundational Pillars and Research Directions, [arXiv 2509.06216](https://arxiv.org/abs/2509.06216), September 2025 (Consultation Request Packs).
- GitHub, [Spec Kit](https://github.com/github/spec-kit) (spec-driven development).
- PIT, [mutation testing for Java](https://pitest.org/), description of the method on the project site.
- Andrej Karpathy, [Sequoia AI Ascent 2026](https://karpathy.bearblog.dev/sequoia-ascent-2026/) (the term agentic engineering).

## Would you like to set up a project as an Agentic Engineering Project?

We look at it together with you and work out how it can be cut into executable tickets.

[Book a call](https://calendar.app.google/jt9JbavAsx3PkHzQ8)
