# Simplicity in model-driven agents and MCP drives real engineering gains | LinearB Blog

> AWS's Clare Liguori on why the model, not the scaffolding, should carry the load in agent development. Discover how simpler agents and MCP drive real gains.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Simplicity in model-driven agents and MCP drives real engineering gains",
      "item": "https://linearb.io/blog/aws-clare-liguori-model-driven-agents-mcp-simplicity"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

Simplicity in model-driven agents and MCP drives real engineering gains

# Simplicity in model-driven agents and MCP drives real engineering gains

![Photo of Andrew Zigler](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

By [Andrew Zigler](https://linearb.io/blog/aws-clare-liguori-model-driven-agents-mcp-simplicity#andrew-zigler)

|

August 21, 2026

![Blog_Simplicity_in_model_driven_agents_2400x1256_e67f24d00b](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/Blog_Simplicity_in_model_driven_agents_2400x1256_e67f24d00b?_a=BAVMn6ID0)

The hardest problem in agent development right now is not building. It is knowing what to leave out. [Clare Liguori](https://linearb.io/dev-interrupted/podcast/aws-clare-liguori-agent-skill-mcp-architecture), Senior Principal Software Engineer at AWS, has spent the last three and a half years watching the field lurch from inline code completion to vibe coding to full agentic harnesses, and the lesson she keeps returning to is that the model, not the machinery around it, should carry the load.

As the technical lead on the open source Strands Agent SDK and a core maintainer of MCP, she sits at the center of two of the most consequential shifts in how engineering organizations ship AI. Both point in the same direction. The scaffolding that once felt like progress has become the thing holding teams back, and the fastest-moving teams are the ones tearing it down.

## **Model-driven agent development lets the model do the heavy lifting**

Strands began inside the Agentic AI org because existing frameworks carried too much cognitive overhead. [Getting something into production took six months](http://linearb.io/blog/sdlc-to-adlc-agentic-software-delivery-transformation). The team wanted a declarative interface that focused on the things that actually matter, the model, the system prompt, the tools, and stripped away everything else.

The timing mattered. The scaffolding built to make older models behave reliably turned into a liability the moment better models arrived. "We would have built a bunch of scaffolding, and then Sonnet 3.5 came out, and we were making the model actively worse because of all of the scaffolding on top," Liguori says, because that scaffolding stopped giving the model the right context. Sonnet 3.7 repeated the pattern. The capabilities jumped, and the harness fought the very reasoning it was meant to enable.

The instinct to build more is deeply human. Engineers form a personal connection to the systems they create, which makes those systems agonizing to tear down even when their entire lifetime has been six months. The model-driven approach asks teams to resist that pull and let the model do most of the work. Assume that in six months a single line change in the agent configuration swaps in a new model, and the new reasoning and tool-calling capabilities become available automatically. That assumption only holds when nobody has boxed the model in with a layer of constraining logic on top.

## **MCP protocol simplification finally makes remote servers realistic**

The same discipline now shapes the MCP spec. The most significant change is how much easier it becomes to build remote servers over the HTTP transport. Standard IO servers have long been the barrier, and Liguori has been pushing to get out of that game entirely. "I think that really any SaaS provider should have an MCP endpoint for their APIs," she says. The trouble is that implementing anything beyond basic tools as a remote provider has been hard.

Elicitation is the clearest casualty. Responding to a user with a form or a URL to gather more information required the server to be heavily stateful, which meant building a streaming API into a web server, and the feedback on that difficulty came through loud and clear. The transport shift changes the math. The spec is moving to a stateless design with typical request-response patterns, which means capabilities like elicitation stop being impossible and start being routine.

Stability drives the rest of the design. The core spec stays deliberately quiet while experimental ideas live in extensions. Tasks, which model long-running jobs rather than short request-response tools, generated churn as the design evolved, so it moved out to an extension where breaking changes do no damage. MCP Apps, already supported in ChatGPT, lets a server provide a full UI widget through the same mechanism. Things graduate into the main spec only once real-world usage proves them out. The AWS MCP server for APIs shows what this simplification buys. [One remote HTTP server exposes roughly 16,000 AWS APIs](http://linearb.io/blog/does-your-software-factory-work) through curated skills owned by individual service teams, instead of hundreds of sprawling individual tools nobody can reason about.

## **Agentic coding assistants are replacing custom-built agents**

Simplification also changes who should build agents at all. When coding assistants became powerful, the case for bespoke agents collapsed. Liguori also works on Kiro, AWS's agentic coding assistant, and internally the effect was dramatic. Thousands of engineers stopped building on-call troubleshooter agents from scratch and instead wrote a small custom agent config against Kiro. The QCLI, now the Kiro CLI, launched to public production in three weeks, a timeline that was previously unthinkable.

[The productivity gains are real and measurable](http://linearb.io/blog/ai-analytics-measure-ai-impact). Pilots with different teams are showing a four to five X increase, and the gains track new habits as much as new tools. Teams that see the jump have changed how they work, not just what they run.

The deeper pattern is organizational. Conway's Law has been applied to agents, so the number of agents a company ships maps directly to its org chart. Every team feels obligated to own one, and customers now describe fleets of 500 agents sprawling across internal teams. That is too many. Most products need one agent plus a set of tools and skills disclosed progressively, not dozens of one-off micro agents each carrying a single skill. Standardizing on a shared assistant, configured many ways, replaces the duplicated bespoke work that org charts keep generating.

## **AI code review automation catches the slop humans miss**

Accountability is the practice that separates the teams pulling four to five X from the ones drowning in output. The old rite of passage was a new hire fumbling a Git command. The new one is an AI slop pull request, generated by a coding assistant and pushed by a human who never read it. The rule holds regardless of authorship. "You have to take accountability for the code that you produced, even if you generated it using a model or if you wrote it by hand, you have to take the same accountability," Liguori says. The assumption on her team is simple. You read it before it becomes a pull request.

Automated review handles the rest. Her teams run AI code review to catch the total slop, but also to catch the nitty-gritty questions humans should not have to spend attention on anymore. Is this maintainable? Did you add tests, and do they make sense? Those checks used to consume human reviewers who missed the forest for the trees, nitpicking style while never asking whether the change was the right thing to ship or whether it touched code too sensitive to break in production. Now the machine gets to be picky. "The AI code reviewer and your AI code generator get to chat with each other," she says, so most of that back-and-forth resolves before a human ever opens the diff.

At an organizational scale, the danger is fragmentation. If every team runs its own review prompts, enforcement splinters. AWS addresses this with internal mechanisms that install custom agents, MCP servers, and skills the way a package manager installs dependencies, plus hooks into the code review system itself so a custom agent can review a pull request and add comments directly. Standardizing those review prompts across the org keeps the quality bar consistent as [the volume of code moving through the codebase climbs](http://linearb.io/blog/8-million-prs-engineering-productivity) past anything a human could read.

## **The fastest teams build context, not constraints**

The model-driven bet has now been tested well beyond the team that made it. Inside AWS, three major projects reached production in under six weeks each before Strands was ever open sourced, which is when the success stopped looking like luck and started looking like a repeatable method. The preview drew the same story from outside. One customer took a goal to route 25% of traffic through agents, picked up Strands, pushed an agent to production in a month, and hit the goal by mid-year. What generalizes is not the framework so much as the discipline behind it. Keep the surface small and let the model carry the load.

That discipline is also the way out of the organizational tangle. For 25 years engineering absorbed the gospel of service-oriented architecture, and now teams are shoving markdown files around, sometimes uploading them to Slack for a colleague. Some order has to emerge, and Liguori's answer is fewer, sharper building blocks. A tool that fetches context or takes an action. A skill that teaches a model how to use those tools. An MCP server, CLI, or API underneath. The question for most teams is not which agent to build but whether they need to own an agent at all, or just a skill.

Her closing [advice to engineering leaders](http://linearb.io/blog/ai-productivity-edge) is the same lesson that opened the conversation. Always think about simplicity. The models are amazing now, and the work is building context around them rather than constraints on top of them, because "the context is what makes all of this work."

To hear more of Clare Liguori's insights on model-driven agent development, MCP protocol simplification, and AI code review automation, listen to the full episode on the Dev Interrupted podcast.

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

![Headshot3_d7231cbda7](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

## Andrew Zigler

Andrew Zigler is a GTM Engineer at LinearB and the host of Dev Interrupted, a twice-weekly podcast and newsletter where 40k+ builders decode the transition to AI-native development and agentic orchestration. A classicist by training with a degree from The University of Texas at Austin, Andrew spent his early career teaching in Japan before channeling his interdisciplinary instincts into the tech world. His polymath background informs everything he builds, from automated workflows to the stories he tells about the seismic shifts reshaping software creation.

### Connect with

[](https://www.linkedin.com/in/andrewzigler)
[](https://substack.com/@zigler)
[](https://x.com/andrewzigler)

## Your next read

[![Cover image for How to keep seeing when your software factory runs in the dark](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_c9af1d9dc4?_a=BAVMn6ID0)](https://linearb.io/blog/software-factory-night-vision)

AI

[How to keep seeing when your software factory runs in the dark](https://linearb.io/blog/software-factory-night-vision)

How to keep visibility as your SDLC runs without humans: LinearB, HumanLayer and Warp on tracking autonomy and measuring quality past the merge. 

[![Cover image for Why the best agentic security removes engineering friction](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/Blog_Whythebestagenticsecurityremoves_2400x1256_e31ce7ae58?_a=BAVMn6ID0)](https://linearb.io/blog/1password-nancy-wang-agentic-security-no-long-lived-secrets)

AI

[Why the best agentic security removes engineering friction](https://linearb.io/blog/1password-nancy-wang-agentic-security-no-long-lived-secrets)

1Password CTO Nancy Wang on why the best agentic security removes engineering friction. Discover how no long-lived secrets keep agents and engineers safe.

[![Cover image for Elite AI-driven engineering teams double PR output while others stall](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/Blog_Elite_AI_driven_Teams_2400x1256_fd33821a9d?_a=BAVMn6ID0)](https://linearb.io/blog/elite-engineering-teams-double-pr-output-ai-benchmarks)

AI

[Elite AI-driven engineering teams double PR output while others stall](https://linearb.io/blog/elite-engineering-teams-double-pr-output-ai-benchmarks)

LinearB CTO Yishai Beeri breaks down benchmark data revealing how elite AI-driven engineering teams doubled their merged PR output while others stalled. Learn...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Simplicity in model-driven agents and MCP drives real engineering gains",
  "url": "https://linearb.io/blog/aws-clare-liguori-model-driven-agents-mcp-simplicity",
  "author": {
    "@type": "Person",
    "name": "Andrew Zigler"
  },
  "datePublished": "2026-08-21T07:00:00.000Z",
  "dateModified": "2026-08-21T07:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1788886686/Blog_Simplicity_in_model_driven_agents_2400x1256_e67f24d00b.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "AWS's Clare Liguori on why the model, not the scaffolding, should carry the load in agent development. Discover how simpler agents and MCP drive real gains."
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Watch now](https://linearb.io/resources/the-great-software-factory-debate)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)