Blog

By now, the pattern should be clear.

Better models matter. But once AI systems are expected to do real work, model quality stops being the whole story. What matters just as much is the harness around the model: the structure that gives the system context, state, tools, recovery, observability, and human control. In practice, this is what determines whether an AI agent architecture is reliable enough for real-world use.

That is where the difference between weak and strong systems starts to appear.

What weak harnesses tend to look like

A weak harness can still look impressive at first.

It may produce fluent answers. It may complete a short task. It may even demo well under controlled conditions. But once the workflow becomes messy, the weaknesses start to surface.

Weak harnesses usually share some combination of the same traits:

• hidden or poorly managed state
• context handled as prompt stuffing rather than structured retrieval or memory
• tool execution that is improvised rather than governed
• little durability when a step fails or the workflow is interrupted
• poor observability when something goes wrong
• weak or missing human checkpoints

The common pattern is not that the model is necessarily weak. The common pattern is that the surrounding system cannot hold together once reality becomes inconvenient.

What strong harnesses tend to look like

A strong harness usually does the opposite.

It makes workflow state explicit. It treats context as a managed system layer rather than a pile of extra text. It wraps tool use inside clearer boundaries. It can retry, resume, checkpoint, and recover. It emits traces that let humans inspect what happened. And it leaves room for approval, intervention, and correction when the workflow matters.

This is what reliable AI agent architecture looks like in practice: explicit state, structured context, tool orchestration, workflow durability, observability, and meaningful human checkpoints.

This does not make the system perfect. It makes it dependable.

That distinction matters. A strong harness is not one that never fails. It is one that fails in ways the system can survive, inspect, and improve.

Why weak harnesses still look good in demos

One reason weak harnesses are easy to overestimate is that demos compress time and complexity.

A short demo hides interrupted workflows, partial failures, stale state, retry logic, messy context changes, and human handoffs. A strong model can cover a lot of structural weakness for a few minutes.

That is why isolated outputs are often misleading. The more serious question is what happens when the task runs longer, tools misbehave, or the surrounding environment changes.

A weak harness often looks strongest right before it is stressed.

Public systems are revealing stronger patterns

Public harness-oriented systems are useful because they show what stronger patterns actually look like in practice.

LangGraph makes explicit state and workflow structure central rather than hidden.

Source URL: https://github.com/langchain-ai/langgraph

Restate’s AI examples emphasize durable execution, retries, and resilience.

Source URL: https://github.com/restatedev/ai-examples

Dapr Agents treats workflows, messaging, state, telemetry, and execution boundaries as part of the architecture itself.

Source URL: https://github.com/dapr/dapr-agents

The OpenTelemetry MCP server shows observability moving closer to the agent layer, making traces more accessible to the system and its operators.

Source URL: https://github.com/traceloop/opentelemetry-mcp-server

The paper Building AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned is also useful because it treats scaffolding, context engineering, and task structure as central engineering problems rather than secondary details.

Source URL: https://arxiv.org/html/2603.05344v1

And the awesome-harness-engineering repository is helpful as a category map because it makes visible how many of these same layers keep reappearing across the field.

Source URL: https://github.com/walkinglabs/awesome-harness-engineering

The point is not that these projects are identical. The point is that they keep converging on the same needs.

A practical way to judge a harness

If you want a more useful question than “How good is the model?”, try asking this instead:

• Can the system represent and update state explicitly?
• Can it supply context in a structured, task-relevant way?
• Can it govern tool use rather than improvising it?
• Can it recover when a step fails?
• Can humans inspect what happened through logs, traces, or checkpoints?
• Can the workflow continue without becoming opaque or brittle?

This is not a scorecard. It is a structural lens.

A harness is strong when the system can keep working under pressure without becoming invisible, fragile, or unrecoverable. That is also what makes reliable AI systems possible outside short-lived demos.

The series-level lesson

This is the broader lesson of the whole series.

Part 1 argued that harness engineering is becoming more decisive. Part 2 showed that context structure matters. Part 3 showed that durability changes the engineering problem. Part 4 showed that public systems keep converging on the same architecture layers.

Part 5 turns all of that into a judgment criterion: the real test of an AI system is not whether it can impress in one moment, but whether its surrounding structure can preserve capability when conditions become real.

Bottom line

The difference between a weak AI harness and a strong one is not whether the model can impress you once. It is whether the surrounding system can preserve capability under real conditions.

That means state, context, tool governance, durability, observability, and human control are not side topics. They are the practical criteria that determine whether an AI system is only persuasive or actually dependable.

That is the larger lesson of this whole series. As models improve, more of the real engineering advantage moves into the harness.

Sources

• langchain-ai/langgraph
• restatedev/ai-examples
• dapr/dapr-agents
• traceloop/opentelemetry-mcp-server
• Building AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned
• walkinglabs/awesome-harness-engineering

One of the easiest ways to misunderstand the current agent landscape is to focus too much on product names.

One system uses graphs. Another emphasizes durable workflows. Another focuses on telemetry. Another packages itself around MCP servers or infrastructure APIs. On the surface, these systems can look very different. But if you compare them at the architecture level, something more important appears.

The same patterns keep coming back.

That is the deeper signal. The field is not only producing more agent frameworks. It is converging on a shared set of harness layers.

Why pattern-level comparison matters

Tool names change quickly. Architecture lessons usually last longer.

If you compare systems only by branding, language, or surface features, you miss the more durable story. The useful question is not which project has the best demo page. The useful question is which design choices keep reappearing when builders try to make agents usable in the real world.

That is why pattern-level comparison matters. It helps separate what is fashionable from what is becoming necessary.

The repository awesome-harness-engineering is useful here because it already organizes the field around recurring categories rather than around a single winning tool.

Source URL: https://github.com/walkinglabs/awesome-harness-engineering

That kind of category map is a signal in itself. It suggests that builders are spending time on shared system problems, not just isolated implementations.

Pattern 1: explicit state

One of the clearest recurring patterns is explicit state.

A weak harness hides workflow state inside model messages, scattered prompts, or untracked local assumptions. A stronger harness makes state visible and structured.

LangGraph is an obvious example because it treats agent execution as a stateful graph rather than a vague sequence of calls.

Source URL: https://github.com/langchain-ai/langgraph

The point is not that every system must literally be graph-shaped. The point is that real workflows need state that can be inspected, updated, and reasoned about deliberately.

Pattern 2: structured context

The second recurring pattern is structured context.

Useful systems keep moving away from the idea that context means pasting more text into a prompt. Instead, they treat context as a managed layer: memory, retrieval, indexing, structure, and task-relevant focus.

This is one reason the harness conversation keeps intersecting with codebase context, memory systems, and retrieval design. The architecture is telling us that context is not just input volume. It is a system responsibility.

Again, the category structure in awesome-harness-engineering is useful evidence because it places context and memory alongside guardrails, evals, observability, and runtimes rather than treating them as side concerns.

Source URL: https://github.com/walkinglabs/awesome-harness-engineering

Pattern 3: tool boundaries and execution interfaces

Another repeated pattern is the way serious systems mediate tool use.

In weak systems, tool execution can feel like an improvised extension of prompting. In stronger systems, tools are wrapped, constrained, typed, mediated, and connected to broader workflow logic.

Dapr Agents is useful here because it frames agent execution in terms of workflows, messaging, state, telemetry, and infrastructure concerns rather than as a single free-floating model call.

Source URL: https://github.com/dapr/dapr-agents

That matters because it shows tool use becoming part of a governed execution interface, not just a trick for making the model look more capable.

Pattern 4: durability and recovery

Once workflows become longer-running, another pattern appears: durability.

Systems that aim at real work keep adding retries, persistence, resumability, and recovery-aware execution. This is not decorative engineering. It is the difference between something that works once and something that can survive production conditions.

Restate’s AI examples are useful evidence because they make durability, retries, and resilience part of the public story rather than hiding them in infrastructure layers nobody talks about.

Source URL: https://github.com/restatedev/ai-examples

This pattern also reinforces a larger point from Part 3 of this series: workflow time changes the architecture.

Pattern 5: observability

A fifth recurring pattern is observability.

As agents become more capable and workflows become more layered, it becomes harder to trust opaque execution. Builders need traces, telemetry, inspection points, and a way to connect bad outcomes back to specific steps.

The OpenTelemetry MCP server is a useful sign of this direction because it suggests observability moving closer to the agent layer itself.

Source URL: https://github.com/traceloop/opentelemetry-mcp-server

LangSmith’s MCP server points in a similar direction, connecting tooling and inspection more directly into the agent ecosystem.

Source URL: https://github.com/langchain-ai/langsmith-mcp-server

This matters because observability is not just a monitoring concern. It is part of how a harness learns, debugs, and improves.

Pattern 6: human checkpoints

One more recurring pattern is human-aware control.

Serious harnesses do not assume perfect autonomy. They assume that humans may need to approve, redirect, inspect, or override system behavior.

This pattern may be less flashy than model demos, but it shows up repeatedly because it reflects real operational conditions. The more consequential the workflow becomes, the more important it is to keep meaningful checkpoints in the loop.

That is also why many harness discussions naturally connect approvals, guardrails, auditability, and intervention. These are not signs that the system is weak. They are signs that the system is being designed for reality.

The deeper takeaway

What matters here is not that every public system looks the same. They do not.

What matters is that the same architectural needs keep resurfacing from multiple directions. Different teams, tools, and ecosystems keep rediscovering the same requirements once they move beyond toy workflows.

That is why this convergence matters. It suggests the field is not just experimenting randomly. It is slowly identifying the layers that serious agent systems require.

Bottom line

Public harness-oriented systems may look different on the surface, but they keep converging on the same architecture layers.

Those layers include:

• explicit state
• structured context
• tool boundaries
• durability and recovery
• observability
• human checkpoints

This is the real signal in the current landscape. The field is not just experimenting with many random agent ideas. It is gradually discovering the same system requirements from multiple directions.

In the final part of this series, I will turn that convergence into a sharper question: if these layers keep reappearing, what actually separates a weak harness from a strong one?

Sources

• walkinglabs/awesome-harness-engineering
• langchain-ai/langgraph
• restatedev/ai-examples
• dapr/dapr-agents
• traceloop/opentelemetry-mcp-server
• langchain-ai/langsmith-mcp-server

A lot of agent demos are misleading in one specific way: they hide time.

A model receives a prompt, calls a tool or two, produces an answer, and the system looks capable. But real agent work rarely happens in one clean burst. It unfolds over time. The agent has to survive partial failures, retries, interruptions, changing context, and multi-step execution. Once that happens, the problem stops looking like prompt engineering and starts looking like workflow engineering.

That is the real shift: as agents move from one-shot responses to ongoing work, durability becomes part of the core architecture.

Why long-running work changes the engineering problem

The moment work becomes long-running, a different class of failure appears.

A tool call times out. A shell command only partly succeeds. An API call fails after earlier steps already changed state. A user interrupts the task and comes back later. The system needs to resume from a meaningful checkpoint instead of starting over blindly.

This is the gap between a system that can produce a good answer once and a system that can make progress reliably.

The paper Building AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned is useful here because it does not describe execution as a single model response. It describes shell integration, task state, tool behavior, and explicit completion signals as part of the system itself.

Source URL: https://arxiv.org/html/2603.05344v1

That framing matters because long-running systems fail in ways that one-shot demos do not show. The problem is not just whether the model can reason. The problem is whether the surrounding system can preserve progress when the world is messy.

One-shot generation is not durable execution

A one-shot workflow can look stable simply because it has not been stressed.

If a model reads input, produces output, and exits, many important system questions remain hidden. What happens if the third step fails after the first two succeeded? What happens if the same task is retried? What happens if a human pauses the process and returns later? What happens if downstream state has changed while the task was waiting?

These are not edge cases. They are normal production conditions.

This is why durable execution matters. Durability means the system can preserve state, resume from checkpoints, retry safely, and recover without losing the integrity of the workflow.

A system that works only when nothing goes wrong is not durable. It is lucky.

What durability actually means

In practice, durability usually includes some combination of:

• persistent workflow state
• explicit checkpoints
• retries and backoff
• resumability after interruption
• safe replay or idempotent recovery paths
• traces and logs for inspection
• human checkpoints for correction or approval

These are not implementation details that sit outside the AI system. They shape whether an agent can do real work over time.

Durability is what allows a system to move from “the model produced something plausible” to “the workflow completed safely and can be inspected, resumed, or retried when needed.”

Public systems are already treating this as infrastructure

The open-source landscape is useful here because it shows what builders are actually investing in.

Restate’s AI examples emphasize durable execution, resilience, retries, persistence, and long-running workflow behavior.

Source URL: https://github.com/restatedev/ai-examples

That matters because it shows durability being treated as a first-class systems concern rather than as cleanup after the fact.

Dapr Agents reflects a similar mindset. The project brings together workflow orchestration, messaging, state, and telemetry around agent execution.

Source URL: https://github.com/dapr/dapr-agents

LangGraph is another clear signal. Its model is explicitly stateful and graph-oriented, which makes long-running workflow structure visible rather than implicit.

Source URL: https://github.com/langchain-ai/langgraph

Even outside AI-branded tooling, durable workflow engines such as Conductor point in the same direction: once workflows become meaningful, resilience and resumability stop being optional.

Source URL: https://github.com/conductor-oss/conductor

Seen together, these systems suggest a broader pattern. Public implementations are converging on the idea that serious agent execution needs workflow memory, retries, replay-aware behavior, and explicit state transitions.

Why this is a harness problem

It is easy to describe failures in long-running tasks as model failures. Sometimes they are. But often the model is only one part of the story.

A stronger model does not automatically decide:

• when to checkpoint
• how to persist state
• how to retry safely
• how to resume after interruption
• how to surface partial progress
• how to let humans inspect or redirect the run

Those are harness choices.

This is why the center of gravity keeps moving outward from the model itself. As models improve, the surrounding execution structure becomes easier to notice. The more you expect from an agent, the more visible durability becomes.

A good harness does not just help an agent start. It helps the agent continue.

Bottom line

The difference between a convincing demo and a dependable agent often comes down to whether the workflow can survive time.

That is why durability, state, and recovery are not secondary engineering polish. They are part of the core architecture of serious AI systems.

Once an agent is expected to work across long tasks, interruptions, retries, and shifting context, workflow durability becomes a competitive layer.

In the next part of this series, I will zoom out from individual failure modes to a broader pattern: the recurring architecture choices that keep appearing across public harness-oriented systems.

Sources

• Building AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned
• restatedev/ai-examples
• dapr/dapr-agents
• langchain-ai/langgraph
• conductor-oss/conductor

AI coding agents often look impressive in controlled demos and short benchmark tasks. They can explain code, generate functions, and suggest patches quickly. But once they are dropped into a real repository, their weaknesses become more obvious.

The problem is not only model quality. A stronger model can help, but it does not automatically create repository understanding. In practical software work, the bottleneck is increasingly whether the system can represent and retrieve codebase context in a form the model can use reliably over time.

That is why structured codebase context is becoming a core harness layer for serious coding agents.

Coding work exposes context failure faster than chat work

A normal chat task can hide a lot of weaknesses. A coding task cannot.

Real coding work depends on relationships between files, symbols, dependencies, tests, shell commands, partial edits, and repository state. The system has to track what changed, what still depends on that change, and what should be inspected next. It has to move between local detail and repository-wide structure without losing the thread.

That is very different from producing a one-shot answer. The challenge is not only generating plausible text. It is navigating a structured environment while preserving task continuity.

This is one reason the recent paper Building AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned is useful. It treats context engineering as a first-class systems problem, not just a prompt formatting detail.

Source URL: https://arxiv.org/html/2603.05344v1

That framing matters because coding agents fail in ways that expose the limits of raw model-centric thinking. They do not only hallucinate. They also lose track of repository structure, miss important references, forget prior steps, and confuse local correctness with system-level correctness.

Bigger context windows are not the same as better context

One common response is to assume that larger context windows will solve the problem. They help, but they do not solve it.

More tokens are not the same as better repository understanding. A coding agent can be given more files and still fail to identify which symbols actually matter. It can see more text and still miss the most important relationships. It can load a larger slice of the repository and still struggle to maintain salience as the task evolves.

In other words, token volume is not a substitute for structure.

This is the central distinction: a codebase is not just a long string. It is an organized system of references, modules, call paths, dependencies, ownership boundaries, and changing states. Treating it as raw text may be enough for a demo. It is often not enough for real work.

What structured codebase context actually means

Structured codebase context means representing a repository in a way that makes its internal relationships usable.

That usually includes some combination of:

• symbol-level indexing
• file and module relationships
• reference and dependency tracking
• graph-like navigation between components
• retrieval tied to structure rather than only keyword similarity
• explicit links between local context and repository-wide context

The point is not to build an abstract graph because graphs sound sophisticated. The point is to reduce navigation failure.

A good coding harness needs a way to answer questions like:

• where is this symbol defined?
• what calls it?
• what else will break if this changes?
• what files are structurally adjacent to this task?
• what part of the repository matters right now?

Those are context questions, but they are also execution questions. They shape whether the agent can make progress without wandering.

Public systems are already moving in this direction

The clearest evidence here comes from public implementations.

GitNexus is a useful example because it approaches repository understanding as a structural problem rather than a pure prompt problem.

Source URL: https://github.com/abhigyanpatwari/GitNexus

That matters because it reflects a broader shift: repository context is increasingly being modeled, indexed, and navigated rather than simply pasted into prompts.

CodeGraphContext pushes in a similar direction. It indexes code into a graph-oriented layer and exposes it through both an MCP server and CLI tools.

Source URL: https://github.com/CodeGraphContext/CodeGraphContext

Again, the point is not that one implementation is the winner. The point is that public source code keeps converging on the same idea: coding agents need access to repository structure, not just larger piles of repository text.

This is also why Part 1 of this series argued that harness engineering is becoming more decisive. Once an agent must work across real files and long task chains, context handling becomes infrastructure.

Why this is a harness problem, not only a model problem

It is tempting to describe context handling as a retrieval trick attached to a model. That understates the issue.

For serious coding workflows, repository context is part of the harness itself. It determines how the system sees the codebase, how it updates its understanding over time, how it narrows attention, and how it keeps multi-step work coherent.

A stronger model may reason better once the right context is in place. But choosing a stronger model does not by itself decide:

• how repository structure is represented
• how relevant context is selected
• how changing state is tracked
• how prior work is remembered
• how partial progress is preserved across steps

Those are harness design choices.

And this is where a lot of real-world agent quality will likely be decided. As model capability becomes more accessible, the competitive edge moves toward systems that can make repository context usable, stable, and navigable.

Bottom line

The next bottleneck in AI coding is not just model intelligence. It is codebase context structure.

That is why structured codebase context is moving from a nice-to-have enhancement to a necessary layer in modern coding agents. For real software work, the question is no longer just whether the model can write code. It is whether the surrounding system can help the model understand where that code lives, what it affects, and what should happen next.

In the next part of this series, I will move from repository understanding to another pressure point in harness design: how long-running agent systems handle state, retries, interruptions, and durable execution.

Sources

• Building AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned
• abhigyanpatwari/GitNexus
• CodeGraphContext/CodeGraphContext

AI development is still mostly described as a model story. A new model ships, benchmark scores improve, context windows expand, tool use gets better, and the discussion moves on to the next release. That story is real, but it no longer explains where a growing share of the engineering difficulty actually lives.

A better description of the current shift is this: as models become more capable, the surrounding execution structure becomes more decisive. The next layer of competition is not just model intelligence. It is the harness around the model — the architecture that gives it context, tools, state, retries, guardrails, and observability.

Harness engineering is what turns AI capability into reliable work.

Why this matters now

This shift matters now for at least four reasons:

• stronger base models are becoming easier to access
• coding agents are making system weaknesses visible in public
• long-running, tool-using workflows are becoming more common
• open repositories increasingly expose architecture, runtime structure, and evaluation logic rather than prompts alone

That changes what builders should pay attention to. It is no longer enough to ask whether a model is smart. The more useful question is whether the surrounding system can make that intelligence dependable.

Better models did not remove system design problems

Stronger models solve some problems, but they do not solve the system around the model.

A more capable model still needs the right context. It still needs boundaries around tool use. It still needs to survive long tasks, partial failures, interrupted execution, and ambiguous states. It still needs a way to explain what happened when things go wrong.

This distinction between model capability and system reliability is becoming one of the most important distinctions in practical AI engineering.

The recent paper Building AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned makes this explicit. It does not frame the problem as “pick a stronger model and let it run.” It frames the system in terms of shell execution, semantic code analysis, tool design, task management, and explicit completion signals.

Source URL: https://arxiv.org/html/2603.05344v1

That framing reflects a broader truth: once an AI system is expected to do real work across files, tools, shell commands, and user checkpoints, the engineering challenge becomes much bigger than prompt quality.

A strong model without a good harness is often just an expensive demo.

What harness engineering actually means

In plain English, harness engineering is the work of building the execution layer around a model so that the model can do useful work in a controlled, repeatable, and debuggable way.

A good harness usually defines some combination of:

• context management
• tool interfaces
• workflow state
• retries and recovery logic
• evaluation hooks
• traces and logs
• guardrails and constraints
• human approval or handoff points

A model call by itself can produce an impressive answer. A harness determines whether that answer becomes part of a usable system.

This is why the term matters. It shifts attention from isolated outputs to execution structure. A harness is what decides how a system receives context, how it takes action, how it records progress, how it recovers from failure, and how humans can inspect or intervene when needed.

Why coding agents exposed this so quickly

Coding agents are one of the clearest places to see this shift because they expose the limits of model-centric thinking almost immediately.

A model answering a single question can hide a lot of weaknesses. A model working inside a real codebase cannot. It has to navigate files, symbols, dependencies, shell commands, repository state, and multi-step tasks. It has to distinguish between partial progress and real completion. It has to avoid losing context in the middle of a long task.

That is why codebase context systems are becoming more important. GitNexus is a useful example because it treats repository understanding as a knowledge graph problem, not just a token problem.

Source URL: https://github.com/abhigyanpatwari/GitNexus

CodeGraphContext moves in a similar direction by indexing local code into a graph database and exposing that structure through both an MCP server and a CLI toolkit.

Source URL: https://github.com/CodeGraphContext/CodeGraphContext

The point is not that one tool will win. The point is that public implementations are converging on the same lesson: for serious coding workflows, bigger models are helpful, but structured repository context is becoming essential.

Public source code is revealing the same pattern

Once you look across public systems, the same architecture keeps reappearing.

LangGraph presents agent behavior as a graph with explicit state transitions and workflow structure.

Source URL: https://github.com/langchain-ai/langgraph

Restate’s AI examples emphasize durable execution, retries, persistence, and resilience.

Source URL: https://github.com/restatedev/ai-examples

Dapr Agents emphasizes workflow orchestration, state, telemetry, messaging, and security.

Source URL: https://github.com/dapr/dapr-agents

The OpenTelemetry MCP server shows observability moving closer to the agent layer itself, making traces part of the accessible tool environment rather than a separate human-only dashboard.

Source URL: https://github.com/traceloop/opentelemetry-mcp-server

Seen together, these are not random implementation details. They point to a shared pattern.

The pattern looks like this

• explicit state instead of hidden flow
• structured context instead of raw token stuffing
• tool boundaries instead of ad hoc tool calls
• retries and durability instead of brittle one-shot execution
• observability instead of opaque behavior
• human checkpoints instead of assumed autonomy

One of the clearest public signs of this shift is how reference hubs now organize the field. The awesome-harness-engineering repository, for example, groups the space into foundations, context and memory, guardrails, workflow design, evals, observability, and runtimes.

Source URL: https://github.com/walkinglabs/awesome-harness-engineering

That categorization matters because it reflects what builders are actually spending time on.

The competitive layer is moving outward

This does not mean model quality stopped mattering. It means model quality is no longer sufficient by itself.

As strong base models become easier to access, more of the practical difference moves into the surrounding system. Which team can represent context better? Which team can recover from failure gracefully? Which team can inspect a bad run and explain what happened? Which team can make long-running work repeatable instead of fragile?

Those are harness questions.

And that is why open source examples matter so much right now. They do not just show that teams are building agents. They show what kinds of system design are starting to become necessary when those agents are expected to do real work.

What builders should pay attention to now

If you are building with AI, it is still worth paying attention to models. But that is no longer where the whole game is.

A better set of questions is:

• how does the system receive and update context?
• how does it represent workflow state?
• how does it call tools and recover from tool failure?
• how does it trace what happened?
• how does it let humans inspect, intervene, or approve?
• how does it turn real-world failures into better evaluations?

These questions sound less glamorous than model launch headlines. But they are increasingly what separate an impressive demo from a dependable system.

Bottom line

The main shift in AI engineering is not that models stopped improving. It is that better models are making the surrounding architecture impossible to ignore.

That is why harness engineering is becoming a core skill. It is the discipline of making AI systems usable, reliable, inspectable, and repeatable under real conditions.

In the next part of this series, I will focus on one of the clearest pressure points behind this shift: why modern coding agents increasingly need structured codebase context rather than just larger models and longer context windows.

Sources

• walkinglabs/awesome-harness-engineering
• Building AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned
• langchain-ai/langgraph
• restatedev/ai-examples
• dapr/dapr-agents
• abhigyanpatwari/GitNexus
• CodeGraphContext/CodeGraphContext
• traceloop/opentelemetry-mcp-server