Bigger autonomous work before closer control
Act big. Bigger than you think, then bigger than that.
Thoughtworks
How teams build software when agents write much of the code, and people stay accountable for what reaches users.
As practitioners of Hyper-Agentic Engineering, we believe that by handing over all technical execution to agents we can produce higher quality software far faster. This software is flexible and will continue to change and evolve. To achieve this, people are responsible for directing the agents, building and improving agentic machinery. Throughout, people remain accountable for outcomes.
Agents change the economics of software delivery. A change that took a day can take minutes, so the constraint moves from writing code to deciding which code should exist and proving that it works. The values, principles and practices on this site describe how Thoughtworks teams handle that shift.
The values state what we care about. A principle turns a value into a rule for decisions, and a practice is one example of a principle at work, drawn from real projects.
Read across for who acts, and down for the unit of work, the machinery that checks it and what follows. Each principle comes with a test you answer from evidence.
| Continuous improvement | Human domain | Agentic domain | |
|---|---|---|---|
| Unit of work |
|
|
|
| Machinery |
|
|
|
| Consequence |
|
|
|
What we care about when agents do much of the work, each as one thing to choose before another.
Each value reads “this before that.” It sets an order: choose the first thing, and fall back on the second only on purpose. The second thing is often the familiar move, or the move from before agents, and teams fall into it when they skip a step. It’s still the right call at times, so each value says when.
The second things are the default moves of two camps. Teams that check each diff by hand fall into closer control, implementation, inspection and fixing the output. That feels responsible, and it limits the work to a person’s reading speed. Vibe coders fall into tacit knowledge, raw speed and settling for whatever the agent decided. That’s fast, and the speed doesn’t last. The values chart the course between them.
Act big. Bigger than you think, then bigger than that.
People own purpose and judgment. Agents own the doing.
Set the boundaries of a solution, then let the agent search inside them.
Write it down if you care about it, or don't expect to get it.
Needing to touch the output is a bug in the machine.
Confidence comes from the checks an agent runs, more than from people reading its work.
Ask why you care. Judge the system by what it does, and its code by what that costs.
Anyone can go fast for three weeks.
The machine is never finished, and nothing it stands on stays still.
Take a position, build it and find out.
Show the trend, not a feeling.
Hyper-Agentic Engineering is something a team does, and the team keeps learning.
Thank you for your advice, feedback and support.
The first Hyper-Agentic Squads were Thoughtworks teams that built software with agents writing the code. These principles began as what the authors saw in those squads: what people still decided, what the agents took on and how the machinery around them improved.
The authors met in October 2026 to write that experience down. The squads remain the clearest example of the principles at work, and the principles are written to be useful beyond them, to any team that wants to deliver faster and better with agents.
Thanking the members of the original Hyper-Agentic Squads that made this happen.
Concrete ways teams apply the principles today.
No change, from a person or an agent, merges until the full set of checks passes on that exact change.