Agentic Engineering, slide by slide · Article 3 · 2026
What is an Agentic Engineering Project?
An Agentic Engineering Project (AEP) is a software project set up so that AI agents can run it largely on their own. Its requirements are written as executable tickets: each work package states what it is for, the tests derived from it and its acceptance criteria, readable by agents and humans alike. The agents build against those tickets and report back only when a decision is needed: a gap in the specification, behaviour nobody foresaw, or an error they cannot resolve. Whatever is undefined, the agent asks for a ticket before acting. Everything, including every change, is measured against the requirements, so the project stays steerable and testable at any size.
Three terms that belong together
- Agentic engineering is the discipline. Andrej Karpathy coined the term for "the professional discipline of coordinating fallible agents while preserving correctness, security, taste, and maintainability". We use it in that meaning.
- Agentic Engineering Project (AEP) is the unit we work in: a whole project with requirements, work packages, dependencies, sign-offs and changes along the way, set up so that agents can run it.
- Executable tickets are the mechanism inside. An executable ticket contains the success criteria the agent measures itself against, the criteria for when a person has to decide, tests plus mutations so the tests validate themselves, and a reference to the project manifest. The manifest sets out what the agent decides, what the documentation prescribes and what a person decides. Article 10 covers them in detail.
Why a project
A language model decides statistically wherever nobody has written down what is wanted. In a prototype that is fine. In a project that has to reach production, cope with change and prove its quality, it is the reason things stall. An Agentic Engineering Project moves these decisions to where they belong: into requirements, tests and acceptance criteria that a person has written and an agent can execute.
That is also why the word is project. A single instruction to an agent is enough for one function. An application for a company has many functions that depend on each other, business units that sign off, and requirements that change while it is being built. Project work has had this structure for decades. An AEP uses it and writes it down so that agents can work with it.
How an AEP is structured: five levels
At the top it is mostly people who work, at the bottom mostly agents. The further down, the more precisely the work is defined, and the smaller the model that does it can be.
- Interviews, demand discovery, strategic assessment. People interview business units and management, clarify the need and assess it. No agent works here.
- Target picture. People create it. Large models assist, for example by sorting interview notes or playing through variants.
- Use cases, user stories, requirements, architecture. People set the direction, everyday models derive the details.
- Specification and documentation. Everyday models write them, people review and approve.
- Executable tickets. Agents execute them, with open-weight models that can also run in your In-House Cloud.
The rule behind it: the more precisely a project and its artefacts are defined, the less rework there is, the fewer tokens it needs and the smaller the model that executes the tickets can be. Where a lot of human knowledge goes in at the top, inexpensive AI is enough at the bottom.
How an AEP begins: the setup phase
An AEP begins with the setup phase. It starts with a skill, a prepared set of instructions with which an agent completes a particular task. Whoever sets up the project can let the skill build it or build it together with the skill. The skill asks for the project structure, the project manifest and the variant of the executable tickets: test-first as in test-driven development, starting from the specification as in spec-driven development, or following another approach. An AEP is agnostic about these paradigms. The choice is whatever suits the requirement, the project and the development.
Why small models are enough for execution
You need a large model where knowledge and judgement are missing: for the target picture, for open questions, for the architecture. In an executable ticket all of that has already been decided. It contains the requirement, the tests with example data and the acceptance criteria. The agent has to turn that into code that passes the tests, and after every run it sees whether it has succeeded. That task is narrow enough for a small model.
This has three consequences. The cost per ticket is low and can be estimated in advance. The model can run in your In-House Cloud. And your data does not have to go to a cloud provider for execution. If a small model fails on a ticket, we look at the ticket first: usually a definition is missing, and a person then makes it.
Where people decide
It is defined when a person is asked:
- If something is not specified, the agent asks for a ticket. It does not decide the gap itself.
- The project manifest sets out what the agent may decide, what is in the documentation and what a person decides.
- Every ticket has a named approver from the business. An agent never signs off.
- The business reads test descriptions in plain language. It does not have to read test code.
How an AEP differs from related approaches
- Vibe coding. You describe what you want and accept what the AI produces. For prototypes this is fast and good. An AEP starts where a prototype is meant to go into production (article 1).
- Spec-driven development. The specification is the source and the code is generated from it, for example with GitHub Spec Kit. An AEP can be set up this way, or test-first; the choice is made when the project is set up (article 10). Tools for spec-driven development mostly work at the level of individual features. An AEP covers the whole project with dependencies, sign-offs and changes along the way.
- Agentic project management. Here agents take over project management tasks. An AEP is a project set up for execution by agents. People lead it.
- Agentic engineering. The discipline of the person who builds with agents. An AEP is the framework in which that discipline takes place in a company.
What the company gets from it
- Steerability. Every change is a new or changed requirement with tests. The agent works through it like any other ticket, and everything built so far is tested against it again.
- Measurable quality. Every requirement has tests, and mutations show that the tests actually find faults.
- Plannable cost. With tickets cut for small models, token costs stay low and plannable, even if large models cost more in future.
- A start from what exists. An existing prototype is a good starting point. It shows what the business wants. In the AEP it becomes a specification that agents can execute and people can sign off.
Sources
- Andrej Karpathy, talk at Sequoia AI Ascent and blog post, karpathy.bearblog.dev/sequoia-ascent-2026, 2026.
- IBM, What is agentic engineering?.
- Ahmed E. Hassan et al., Agentic Software Engineering: Foundational Pillars and Research Directions, arXiv 2509.06216, September 2025.
- GitHub, Spec Kit.
- Agentic Project Management, open-source framework, github.com/sdi2200262/agentic-project-management.
- Martin Fowler, Vibe Coding.
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.