The Architecture of Agency: Why Less Scaffolding Wins

Clare Liguori explains that the biggest obstacle to building production-grade AI agents is the human habit of over-engineering. By tracing the history of agent frameworks, from early, brittle prompt-parsing loops to modern model-driven designs, Liguori shows that "scaffolding" often creates the very reliability problems it aims to solve. The hidden cost of heavy orchestration is that it keeps developers from using the rapid, compounding capabilities of newer models. This analysis helps engineering leaders and developers build durable AI systems by prioritizing simplicity and deterministic verification over complex, fragile workflows. This shift provides a competitive advantage in deployment speed and system robustness.

The Hidden Cost of Helpful Scaffolding

Most developers try to improve AI agent reliability by building complex prompt pipelines and procedural workflows. They attempt to force the model into predictable behavior through mega-prompts and rigid orchestration. Liguori suggests this is a trap. As models evolve, this scaffolding becomes a liability, artificially constraining the model from using its own training data and tool-selection capabilities.

"We found that as the models were getting better and better, we were actually making reliability and power of what the agent could do worse because we were kind of artificially constraining the model."

-- Clare Liguori

When you build a system that relies on a specific model quirks, you are not building an agent; you are building a fragile custom harness that breaks the moment the underlying model improves. By shifting to a model-driven approach, where the model is trusted to choose its own tools and context, teams can achieve higher accuracy with less maintenance. The immediate benefit of a complex workflow is a sense of control, but the downstream effect is a system that cannot adapt to the rapid pace of model innovation.

Why Steering Beats Workflows

Conventional wisdom suggests that if you need determinism, you must build a procedural workflow using if/then/while loops. Liguori argues that this is a category error. Workflows are essentially brittle, single-use scripts. Instead, she advocates for steering, a pattern where developers inject deterministic checks into the agent trajectory.

Steering hooks allow you to look at the full history of an agent actions, not just the next step, to verify that critical business logic is followed. This creates a just-in-time verification layer that is more durable than a static workflow.

"Steering takes a different approach where... it is just in time verification of what has already happened as opposed to when I am building the agent. I am going to say exactly the set of steps that needs to take like a workflow."

-- Clare Liguori

The competitive advantage here is profound. Because steering is decoupled from the agent internal logic, you can update your business rules without redesigning the entire agent. This approach allows developers to reach 100 percent accuracy on critical tasks, like loan processing, by treating the agent as a flexible engine guided by deterministic guardrails, rather than a rigid procedural machine.

The 18-Month Payoff: From Prompting Treadmill to Determinism

The prompting treadmill is the result of trying to fix agent errors by adding more rules to a system prompt. Over months, this creates a bloated instruction set that is expensive to run and prone to hallucination. Liguori systems-thinking approach replaces this with a ledger of agent trajectories.

By treating the agent history as a searchable, evaluatable ledger, developers can identify optimal paths and inject deterministic Python code to validate inputs and outputs. This moves the burden of reliability from the prompt, which is probabilistic, to the code, which is deterministic. The payoff is delayed, as it requires the effort of writing validation functions, but it creates a massive separation from competitors who are still struggling with prompting treadmill instability. Teams that invest in this deterministic verification now will find their agents are cheaper, faster, and more reliable as they scale.

Key Action Items

• Audit your scaffolding: Over the next quarter, identify which parts of your agent framework exist only to fix the model, such as parsing loops or mega-prompts. If the model can now handle these tasks natively, remove the code.
• Adopt steering over workflows: For new automation projects, move away from rigid if/then workflows. Implement steering hooks that verify the full trajectory of an agent actions. This pays off in 6 to 12 months by reducing technical debt.
• Implement deterministic validation: Use Python functions to validate tool inputs and outputs. This is the most effective way to prevent hallucinations and ensure business process integrity.
• Start with deterministic use cases: When building agents, choose tasks where trajectories can be evaluated deterministically, such as data extraction or API orchestration, rather than open-ended chat, which is harder to measure.
• Shift from agents to MCP servers: Before building a new agent, ask if your team could instead provide an MCP (Model Context Protocol) server. This allows existing agents to access your data without adding the complexity of a new, standalone agent.
• Invest in offline evaluation: Instead of relying on manual testing, build a system to export agent trajectories to your tracing provider. This allows you to evaluate 1,000 plus runs for quality, creating a long-term advantage in system stability.