Community

translate Automatic translation · View original

Harness engineering: why AI needs a harness, not just prompts

Canal Ia Para Agilistas

1 May 2026
Harness engineering: why AI needs a harness, not just prompts
Many professionals have already lived the same scene: an AI agent delivers something that looks brilliant, but on calm review weak sources, unjustified decisions, skipped steps, or a confidence that doesn't match the evidence appear. The problem isn't always "the model." Often it's the environment we gave it to work in. Harness engineering proposes an uncomfortable but useful idea: if we want more reliable agents, we need to design better harnesses, not just write better instructions. This article is part of a content series that Scrum Manager is developing on Harness Engineering. If you want to move from reading to practice, a new topic is already available in **Skill Arena** dedicated to training this discipline. And, if you are a member of the Agile Club, you can go deeper with **two specialized state of the art resources: one for knowledge workers and another for developers.**

During the first years of generative AI adoption, much of the professional conversation revolved around the prompt. Knowing how to ask became a visible skill, almost a craft. But when the work stops being a one-off query and becomes research, analysis, product development, documentation, code review, process design or decision support, the prompt starts to fall short.

A prompt can guide a response. A harness guides a work system.

The difference is not minor. When we ask an agent to "analyze this report," "prepare a proposal," "review this backlog" or "build this feature," we don't just need it to generate text. We need it to know where the sources are, what criteria it must respect, what it must not touch, how it should verify what it produces, when it should stop and what evidence it must leave before declaring something finished.

Birgitta Böckeler, of Thoughtworks, formulated in April 2026 a distinction that helps organize this terrain: an agent's external harness is made up of guides and sensors. Guides act before the agent produces; sensors act afterward, helping to detect errors and correct them. Moreover, both can be computational or inferential.

This way of seeing it shifts the question. The more mature question is: what work system does AI need in order to produce something reviewable, traceable and useful?

An agent is not a teammate

In agility it is important to be especially careful with language. Calling AI a "teammate" may feel comfortable in an informal conversation, but it introduces a dangerous confusion. An agent can execute tasks, consult materials, generate alternatives, detect inconsistencies and speed up work. But it does not assume professional responsibility, does not understand the political context of an organization the way a person does, has no commitment to the product, and does not answer for the consequences of a decision.

For that reason, for an agile team, AI should be understood as a tool with capacity for action, not as another team member. This distinction protects something essential: responsibility remains human. The team decides which problem deserves attention, which trade-offs it accepts, which risks it communicates and what quality it considers sufficient.

Harness engineering does not contradict this idea; it reinforces it. A good harness does not aim to "release" AI to work without human judgment. It aims to concentrate human judgment where it adds the most value: defining intent, limits, evidence, standards and control points.

OpenAI summarized this very directly in its internal Codex experiment: "Humans steer. Agents execute." In that case, the team stated it had built an internal beta with zero lines of code written manually, in roughly a tenth of the estimated time, but the important lesson was not "the AI did everything." It was that humans shifted to designing environments, specifying intent and building feedback loops.

Guides: what the agent needs to know before acting

A guide is any element that orients behavior before the agent produces. In software it can be an AGENTS.md file, an architecture guide, a testing convention or a pull request template. In knowledge work it can be a brief, an editorial guide, a glossary, a taxonomy, a list of acceptable sources or a research protocol.

The key is that a guide should not be documentary decoration. It must be operational.

Writing "This article must be rigorous" is not the same as writing: "Every figure must come with a source, year and scope; if there is no verifiable source, rephrase without the figure or mark the data as pending verification." The first sentence expresses an aspiration. The second changes the agent's behavior.

In an agile team, guides can take very concrete forms. A Product Owner who uses AI to prepare discovery hypotheses can give the agent a template that forces separating evidence, assumption and interpretation. A Scrum Master analyzing retrospectives can use a glossary of organizational dysfunctions to avoid vague diagnoses. A team working with living documentation can set rules about which sources take priority and which terms must not be used ambiguously.

Here a fundamental idea appears: what is not encoded in the environment does not exist for the agent. If a decision was made in a meeting but not recorded, the AI cannot reliably respect it. If the team has a tacit convention that was never documented, the agent will violate it sooner or later. Not out of bad intent, but because it works with the signals available to it.

Sensors: what detects errors after acting

Sensors are the other side of the harness. They observe what was produced and generate signals for correction. In software we are used to them: tests, linters, static analysis, continuous integration pipelines. In management, product or research we usually have weaker sensors: human review, critical reading, checklists, contrast with sources or validation with stakeholders.

The current challenge consists of turning part of that review into more explicit and actionable sensors.

A weak sensor says: "The document is not sufficiently substantiated." A useful sensor says: "Section 3 contains three quantitative claims; two have a source and one does not. The unsourced claim is this one. Fix it by locating a verifiable source or rephrasing without the numerical data."

Böckeler insists that sensors are especially powerful when they produce signals optimized so that the agent itself can self-correct. She also warns that computational controls are usually preferable when possible: they are faster, cheaper and more reliable within their scope than inferential controls based on another model.

This does not mean inferential reviewers have no value. A second agent can act as a skeptical reader, editorial critic, risk reviewer or coherence evaluator. But one should avoid naive faith: a model reviewing another model does not automatically make the result true. It can detect interesting semantic problems, but it remains probabilistic.

For Scrum Manager work, for example, an editorial sensor could check whether the text distinguishes between individual, team and organizational level; whether it avoids promising magic solutions; whether it separates hypotheses from evidence; whether the references are real; and whether the closing invites debate instead of closing the topic with a universal recipe.

The real change: iterate the harness, don't scold the model

When an agent fails, the usual reaction is to write something like: "Don't make up sources," "I told you to be more rigorous" or "do it better." It is understandable, but not very effective. The model does not learn from our frustration in the strong sense of the term. What does change its behavior is modifying the environment in which it works.

The steering loop that Böckeler describes proposes exactly that: when a failure repeats, the human should improve the harness. If context is missing, a guide is added. If detection is missing, a sensor is added. If the agent tries to do too much, the scope is reduced. If it gets lost among materials, the structure of the environment is improved.

This approach fits very well with the agile mindset, but with a warning: it is not about ritualizing improvement, but about making it effective. Saying "we inspect and adapt" is not enough. The question is: what concrete change in the system will prevent this error from repeating?

Consider a simple case. An agent helps prepare an article and cites nonexistent studies. The bad solution is adding to the prompt: "Don't make up studies." The good solution is creating a work rule: every reference must include author, year, title and verifiable source; before closing the article, a specific reference check is run; any unverified source is removed or marked as pending. That is no longer advice. It is a control.

Long tasks: the problem of memory and continuity

Harness engineering becomes especially relevant when the work does not fit in a single conversation. In November 2025 Anthropic published an analysis of long-running agents pointing out a problem that is simple to understand: agents work in discrete sessions, and each new session starts without direct memory of what happened before, unless the system provides it with persistent artifacts. Its proposal combined an initializer agent, which prepares the environment and breaks down the work, with an execution agent that advances incrementally and leaves evidence for the next session.

This idea is very applicable beyond code. A team preparing a teaching guide, a market research study, a series of articles or a process redesign should not depend on "the conversation remembering everything." It should maintain living files: brief, decisions, sources, glossary, progress status, pending items, versions and acceptance criteria.

In March 2026 Anthropic expanded this line with harness designs for developing long-running applications, including decomposition into manageable parts, structured handoff artifacts and architectures with planner, generator and evaluator agents. It also described frequent failures of naive implementations: loss of coherence when the context fills up, premature closures, and the need for restarts with structured handoff.

The lesson for agilists is clear: if we use AI for complex work, we need to treat the environment as an internal product. It must be navigable, versioned and understandable for a new session. If a new person would not understand the project in a few minutes, the agent probably would not either.

Context, tools and open standards

The harness does not live in isolation. It depends on how the agent accesses context, tools and data. That is why standards and conventions are consolidating around the agentic ecosystem.

Anthropic presented the Model Context Protocol in November 2024 as an open standard for connecting AI assistants with the systems where data lives: repositories, business tools, databases or development environments. Later, in December 2025, the Linux Foundation announced the Agentic AI Foundation, with MCP, goose and AGENTS.md as founding projects; it described AGENTS.md as a simple convention for giving agents project-specific instructions in a predictable way.

For an agile team, these moves matter for a practical reason: the more standardized the way agents receive instructions, access tools and respect limits, the easier it will be to govern their use. And governing does not mean bureaucratizing. It means the team knows what data it can use, what actions it can execute, what permissions it has, what evidence it leaves and what human review each type of task requires.

Here there is a real organizational tension. Many companies are incorporating AI in a fragmented way: each person uses their own tool, prompts, documents and shortcuts. At first it looks like speed. Over time it can become operational debt: outputs that are hard to audit, scattered sources, decisions without traceability and dependence on individual practices that no one else can reproduce.

The verification gap

One of the most uncomfortable risks of AI agents is that they can produce very persuasive results before being correct. The text sounds good. The code looks orderly. The analysis has structure. The recommendation is reasonable. And yet, something critical may be wrong.

This gap between appearance and verification is not new, but AI amplifies it. In a professional environment, "done" should not mean "the agent delivered it." It should mean "it passed the agreed controls."

In research and analysis, this implies verifying sources, separating data from interpretation, declaring uncertainty and exposing contradictory evidence. In product, it implies checking whether the recommendation connects with real outcomes, not just outputs. In Scrum, it implies not turning practices into dogmas or team diagnoses into simplistic judgments. In scaling and leadership, it implies recognizing when a problem lies not in individual behavior but in incentives, structure, power or culture.

Böckeler identifies the behaviour harness as a frontier still open: verifying that the system actually does what it should remains harder than verifying structure, style or maintainability. In software, it is not enough for the AI-generated test suite to be green, because it may be validating a misunderstanding. In knowledge work something similar happens: a report can meet the template and still not answer the important question.

That is why human judgment does not disappear. It shifts location. Reviewing every sentence may be less important than clearly defining the questions the work must answer, the minimum acceptance criteria and the objections it should withstand.

How to start without overdesigning

Not every team needs a sophisticated system of agents, sensors, hooks and subagents. In fact, overdesigning the harness can be another form of waste. To start, five pieces are usually enough.

First, a brief master guide: what we are doing, for whom, with which standards and what is prohibited. Second, a materials structure: valid sources, base documents, glossary, templates and good examples. Third, a decision log: what was decided, when, why and with what implications. Fourth, a checklist before closing deliverables. Fifth, a human review routine that is not ornamental.

From there, the harness should grow from real pain, not fashion. If the agent repeatedly fails on terminology, a glossary and a term sensor are created. If it invents references, a bibliographic verification is created. If it scatters, WIP is reduced and work proceeds task by task. If it breaks a convention, the convention is turned into an automatic check when possible.

This logic is very close to continuous improvement: not improving "in general," but closing concrete loops.

For those who want to practice this approach in a guided way, Scrum Manager has included in Skill Arena the Harness Engineering topic, focused on training skills such as distinguishing intelligence from agency, designing guides and sensors, preparing environments that pass the cold-start test, applying pass-state gating, measuring harness quality and deciding when it is not advisable to use an agent. The intention is not to learn "AI tricks," but to develop professional judgment for working with agents in a more reliable and verifiable way.

What changes for scrum masters, product owners and teams

For a Scrum Master, harness engineering can help design more rigorous analysis spaces. An agent can review retrospectives, detect patterns of impediments or prepare facilitation questions, but it needs clear limits: no diagnosing people, no attributing intent without evidence, no confusing symptoms with root causes and no proposing solutions beyond the team's level of influence.

For a Product Owner, the harness can improve discovery and decision-making. It can force the agent to separate hypotheses, evidence, expected impact, risk and learning cost. It can also prevent it from turning stakeholder wishes into "user needs" without validation.

For a development team, the harness can reduce friction if it turns tacit standards into visible rules. But it can also generate false security if everything is delegated to AI without adequate sensors. Speed without verification is not agility; it is rapid accumulation of debt.

For leaders and training centers, the challenge is different: teaching tools is not enough. Criteria of use must be taught. When is it advisable to use an agent? When not? Which tasks require mandatory human review? Which data must not be uploaded? What minimum evidence should an AI-assisted deliverable leave?

An emerging discipline, not a closed answer

The state of the art as of May 2026 shows a discipline in formation. There are solid concepts—guides, sensors, context, verifications, persistent artifacts, external harnesses—but there are still open questions. The harness designs themselves age as models improve. Anthropic noted this when explaining that certain controls needed for one model could become "dead weight" when the next model handled that behavior better.

This is a good vaccine against dogmatism. Harness engineering should not become yet another closed framework. It is more useful to understand it as a design practice: observe how AI-assisted work fails, turn the lessons into controls and periodically review whether those controls still make sense.

For the agile community, the debate deserves attention because it touches a fundamental question: how do we maintain responsibility, learning and quality when part of the execution is carried out by probabilistic systems?

It does not seem sufficient to answer "with better prompts." Nor does it seem sensible to answer "letting AI work alone." Between both extremes appears a more mature space: designing harnesses that make the work more legible, verifiable and governable.

Perhaps the practical question to start with is not "which agent should we use?" but this: if tomorrow a new session had to continue our work without knowing us, what would it need to read, what limits should it respect and how would it know that what it produced is actually good?

If this question resonates with you, you can keep exploring through three complementary paths.

As always, the debate is not closed. Which part of your harness is most mature today: the guides, the sensors, the governance or human review? And which one still depends too much on individual habits that are hard to scale?

References

  • Anthropic Engineering,
    • (2024). Introducing the Model Context Protocol.
    • (2025). Effective harnesses for long-running agents.
    • (2026). Harness design for long-running application development.
    • (2026). Scaling Managed Agents: Decoupling the brain from the hands.
    • (2026). Demystifying evals for AI agents.
  • Böckeler, B. (2026). "Harness engineering for coding agent users". Martin Fowler.
  • Hsieh, C. P. et al. (2024). "RULER: What’s the Real Context Size of Your Long-Context Language Models?" NVIDIA / arXiv.
  • Liu, N. F., Lin, K., Hewitt, J., Paranjape, A., Bevilacqua, M., Petroni, F., & Liang, P. (2023/2024). "Lost in the Middle: How Language Models Use Long Contexts". arXiv / TACL.
  • Lopopolo, R. (2026). "Harness engineering: leveraging Codex in an agent-first world." OpenAI Engineering.
  • Linux Foundation. (2025). Linux Foundation announces the formation of the Agentic AI Foundation.

Take part in the poll

This article includes an active poll in the Scrum Manager community.

poll View the poll in the community