{
  "video": {
    "id": "jJQoVkd5yLg",
    "title": "Why We Deleted Our MCP Server and Rebuilt It — Abhi Arya, Reducto",
    "duration": 1000,
    "upload_date": null,
    "channel": "AI Engineer",
    "source": "AI Engineer",
    "event_format": ""
  },
  "analysis": {
    "video_id": "jJQoVkd5yLg",
    "title": "Why We Deleted Our MCP Server and Rebuilt It — Abhi Arya, Reducto",
    "one_liner": "Reducto deleted a Claude Code-built MCP server that gave every API endpoint its own tool, because users treated it as an 'auto mode' agent that was confidently wrong. They rebuilt it with fewer tools that carry the structure of real work (composite tools like classify-to-extract, a pipeline snapshot tool, contextual next-step guidance), made uncertainty visible, and rewarded the agent for asking instead of guessing.",
    "summary": "The talk argues that agent-first software is an architecture problem, not a model or prompt problem. The question that matters is who pays when the agent is wrong. Reducto's first MCP server mapped every API endpoint to a tool in one large file. It worked in a curated demo, then broke once the whole team used it: given half-baked customer descriptions, the agent confidently built workflows that neither it nor the user could explain. The rebuild constrains the agent with fewer tools that encode domain expertise and state. It makes both outcome uncertainty and the agent's own uncertainty visible, keeps the human as the final judge, and adds instrumentation so the MCP's guidance improves for each org and user.",
    "key_points": [
      "Three architectures, defined by who pays for the agent being wrong: 'auto mode' (optimise for autonomy; errors are confident and invisible, and your customers pay), 'user-first' (give the user every knob behind a weak agent, which ends up as a chatbot that limits both user and agent), and the winner, 'agent experience in service of the user' (rich, scoped capabilities whose work the human can check).",
      "The MVP MCP server was built with Claude Code, with one MCP tool for every API endpoint in a single large file. It looked good in a curated demo, but 'the standalone demo told me nothing at all'. When the whole team got it, the agent would take a half-baked description from a customer call or a Notion page, build a whole workflow end-to-end and say it was right, and nobody could explain what the workflow did.",
      "The fix was architectural, not more system prompt. The whole file was deleted in one commit and replaced with fewer tools that carry the structure of real work. For example, routing the classify endpoint into an extract node became a single classify-to-extract tool that chains automatically, and after each step the agent gets contextual guidance on what comes next.",
      "Because agents are stateless, they added a snapshot tool: one call returns the live pipeline state, including context for the whole flow and the errors with specific error codes. The agent can then reference what actually exists instead of guessing variable names.",
      "Runtime failures happen quietly. A pipeline runs across 100 documents and misses a scan on page 30, or the user never said what document types would go in. The fix was making uncertainty visible: Reducto's Extract outputs confidence scores and bounding boxes, which go back into the model to improve the extract schema over time.",
      "The agent also has to surface its own uncertainty ('I can read this two ways'). Evals were changed to fail the agent for building on shaky assumptions, and the harness was prompted to use ask-user-question tools, like the one in Claude Code, so that asking is rewarded over guessing.",
      "Instrumentation: every MCP session's prompts were logged, and the sales team exported their Claude Code sessions. This tracked where humans overrode the agent, where confidence was low, and where it asked questions. The findings flowed back into the MCP's long-term guidance, a self-improving loop for each org or user.",
      "Adoption was the signal. The MCP was exposed as product tools in Claude Enterprise without anyone being told to use it, and sales and other staff wired it into their workflows on their own. They learned about a customer from CircleBack or Slack before a call, built a pipeline for them, and trusted the result enough to show high-value customers."
    ],
    "takeaways": [
      "Don't expose your raw API as one MCP tool per endpoint. Build fewer, composite tools that encode the right patterns, state and validators, so the correct path is also the simplest one for the agent.",
      "Give stateless agents a single snapshot tool that returns live system state and specific error codes, so they reference reality instead of hallucinating names.",
      "Make uncertainty visible: feed confidence scores and similar signals back to the model, and have it explain to the user what it did and why so the human can review it.",
      "Write evals that fail the agent for unfounded assumptions, and prompt the harness to use ask-user-question tools, so clarifying beats guessing.",
      "Log MCP sessions, human overrides, low-confidence points and questions asked, then feed them back into the tool guidance. Test with the real team, not a curated demo."
    ],
    "topics": [
      "mcp",
      "agents",
      "agent experience",
      "tool design",
      "human-in-the-loop",
      "evals",
      "document processing",
      "observability"
    ],
    "tools": [
      "Reducto",
      "MCP",
      "Claude Code",
      "Claude Enterprise",
      "Notion",
      "Slack",
      "CircleBack",
      "Harvey",
      "Scale AI"
    ],
    "quotes": [
      {
        "text": "Agent-first software is inherently an architecture problem.",
        "at": "02:30",
        "url": "https://www.youtube.com/watch?v=jJQoVkd5yLg&t=150s"
      },
      {
        "text": "We built something that could communicate with our system, but we hadn't built something that could actually work with it.",
        "at": "06:09",
        "url": "https://www.youtube.com/watch?v=jJQoVkd5yLg&t=369s"
      },
      {
        "text": "By moving context out of the prompt and into structure, the agent stopped guessing and started referencing.",
        "at": "07:53",
        "url": "https://www.youtube.com/watch?v=jJQoVkd5yLg&t=473s"
      },
      {
        "text": "when your agent is really confidently wrong, who finds out and how fast did they find out?",
        "at": "15:54",
        "url": "https://www.youtube.com/watch?v=jJQoVkd5yLg&t=954s"
      }
    ],
    "words": 3182
  },
  "summary_url": "/#jJQoVkd5yLg",
  "transcript": {
    "html": "/transcripts/jJQoVkd5yLg.html",
    "txt": "/transcripts/jJQoVkd5yLg.txt",
    "vtt": "/transcripts/jJQoVkd5yLg.vtt"
  }
}