Thoughtworks

Hyper-Agentic Engineering

How teams build software when agents write much of the code, and people stay accountable for what reaches users.

A loop of four connected nodes, showing a person and agents passing work around a cycle of plan, change, check and review.

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.

Principles

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 improvementHuman domainAgentic domain
Unit of work
  • Make the unit of work bigger, and measure it.

    Test: Is what you hand the agent bigger than last month? Show the trend, not a feeling.

  • Hand over goals, not tasks, as big as you can assess.

    Test: Could you demo the result to a stakeholder? Leave it building overnight? Review it in one sitting?

  • The agent sees and acts wherever a human can.

    Test: List what engineers look at and touch, such as CI, logs, staging and production telemetry. Which of those does the agent have access to, with nobody copying and pasting?

Machinery
  • Said it twice? Make it a check.

    Test: What did you tell the agent more than once this week? Is it an automated check yet?

  • Define and enforce the qualities you care about, or don’t expect them.

    Test: Where is each quality you care about written down? What fails when one breaks?

  • The agent isn’t done until the checks pass.

    Test: When the agent says it’s done, which checks did it run? How often does a human find something the checks missed?

Consequence
  • Span and batch keep growing, or you’ve stalled.

    Test: Are span and batch bigger this quarter than last?

  • Humans spend their time on problems and experiments, not on reviewing output.

    Test: What share of last week went on problem analysis and experiment design, and what share on reading what the agent produced?

  • No human reads or writes code.

    Test: When did someone last open the code? Treat each time as a bug in the machinery, and fix the cause.

Principles

Values

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.

Authors

The people who wrote these values and principles, in October 2026.

  • Giles Edwards-Alexander
  • Chris Ford
  • Shweta Justice
  • Beatrice Kern
  • Lucy Kurian
  • James Lewis
  • Kief Morris

Thanks

Thank you for your advice, feedback and support.

  • Scott Davies
  • Martin Fowler
  • Andrew Harmel-Law
  • Rob Horn
  • Alexandra Lovin
  • Kaushik Sarkar
  • Bharani Subramaniam
  • Matteo Vaccari

Building upon the original Hyper-Agentic Squads

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.

  • Gayane Alaverdyan
  • Christoph Burgmer
  • Alex Comunian
  • Rafael Ferreira
  • Alessio Ferri
  • Rushil Gala-Shah
  • Philipp Gerhard
  • Marina Goldina
  • Ioan-Cristian Ivascu
  • Shweta Justice
  • Erica Kastner
  • Beatrice Kern
  • Daniel Mircea
  • Barbara Rekowska
  • Matias Vizcaíno

Example practices

Concrete ways teams apply the principles today.