The AI intelligence brief
for builders who ship agents

Anthropic's tool-use streaming lands for Claude 3.7 — Multi-tool chains that previously required full sequential completion can now stream mid-chain. Real-world impact: agent pipelines that previously took 8–12s round-trips are down to 3–4s. If you're running production agents, this is worth upgrading immediately. via @alexalbert__ — thread breaking down the latency delta with benchmarks

@swyx on the "AI Engineer" identity crisis — A sharp thread arguing AI engineers are actually closer to product builders than traditional SWEs. The key point: the skill gap isn't coding, it's judgment about what to automate. Reshaping how a lot of teams are thinking about hiring. via @swyx on X

@karpathy's take on fine-tuning vs. prompting in 2026 — The conventional wisdom ("just prompt better") is breaking down for production agentic use cases. Karpathy outlines exactly when fine-tuning is worth the overhead — and it's more nuanced than most guides admit. via @karpathy on X

Why Pydantic AI is worth your attention right now

If you've built with LangChain or vanilla function-calling, you know the pain: you define a tool schema, the LLM returns something close-but-not-quite, and your parser breaks at 2am on Friday. Pydantic AI solves this by making type-safety the core primitive — not an afterthought.

The architecture is clean: define your agent, declare your result type as a Pydantic model, and the framework handles retrying until the LLM returns something that actually validates. No custom error handling. No manual retries. The loop just works.

Here's the pattern that matters most for multi-agent systems: The upstream: validation errors get sent back as context, so the LLM learns from its own mistake in the same run. Works with Anthropic, OpenAI, and Gemini out of the box. Dependency injection pattern for tools is clean too — worth the docs read.

Qwen2.5-72B-Instruct on a single A100: numbers that surprised us

We ran Qwen2.5-72B-Instruct-Q4_K_M through 40 agentic tasks (tool calling, structured output, multi-step reasoning) on a single A100 80GB. At Q4_K_M quantization it loads clean with ~5GB headroom.

Results: 89% tool-call accuracy on our test suite (vs 94% for claude-3-5-haiku at API). Throughput: ~28 tokens/sec generation. For local deployments where you can't send data to the cloud, this is the current best option. The instruction-following on structured output is noticeably better than Llama 3.3 70B at the same quant level.

Quick setup with ollama:

Google's A2A protocol is getting enterprise traction faster than expected — 11 companies now have working A2A integrations in production. The key insight from the latest adopter case studies: the hard part isn't the protocol, it's agreeing on agent identity and trust scope. Who decides what Agent A is allowed to ask Agent B to do? No one has a clean answer yet, but the tooling is moving fast.

MCP (Model Context Protocol) hits 1,200+ community servers — The ecosystem is growing faster than the spec. Notable new entrants this week: an MCP server for Notion that actually handles nested pages correctly, a Postgres MCP with schema introspection, and a GitHub MCP with PR review context. If you're building agent infra, check the registry before rolling your own integration.

Samuel Colvin (creator of Pydantic): "The agent loop is just function calling with memory"

A thread that cuts through the hype: every major agent framework is doing the same thing under the hood — call the model, call tools, feed results back. The differentiation is in how they handle failures, model state, and validate output. Pydantic AI's bet: get the output contract right and everything else gets simpler. via @samuel_colvin on X

@swyx: "The model isn't your reliability problem. Your output schema is."

Most "LLM is unreliable" complaints are output parsing failures, not model quality issues. Claude 3.7 and GPT-4o are remarkably consistent when given a tight schema. The failure mode: asking for freeform JSON and regex-parsing it at 3am. via @swyx on X

Anthropic's structured outputs beta: native enforcement at the API layer

Claude 3.7 now supports constrained decoding for JSON schemas. Combined with Pydantic AI's retry loop, you get two layers of validation. Early benchmarks: 40% drop in parsing failures on complex nested schemas vs. prompt-only enforcement. via @alexalbert__ on X, confirmed in Anthropic docs

The core pattern every production agent should use

The shift isn't just about Pydantic AI the library — it's about treating agent outputs as typed contracts between components. The retry mechanism is the key: when the model returns something that doesn't validate, Pydantic AI serializes the validation error and sends it back as context. The model learns from its own mistake within the same run. In practice, 95%+ of validation failures resolve within 1 retry. Multi-agent dependency injection

For multi-agent systems, dependency injection lets you pass shared resources (DB connections, API clients, config) into agents without global state. Makes testing trivial: pass mock deps, assert on typed output. No patching, no global mocks.

Running Pydantic AI with local models: Ollama + structured output

Pydantic AI works with any OpenAI-compatible endpoint, including Ollama. Best local models for structured output as of March 2026:

• Qwen2.5-72B-Q4_K_M — Best overall. 89% tool-call accuracy. Requires A100 or 2x 3090.
• Mistral-Small-3.1-24B — Best for consumer hardware (fits in 20GB VRAM). 78% accuracy.
• Llama 3.3 70B-Q4_K_M — Reliable fallback, widely tested. Less consistent on deep nested schemas.

CrewAI 0.9 ships with Pydantic AI integration — The two frameworks are converging. CrewAI's new Task output schema feature lets you define a Pydantic model as expected output type for any task. Next issue: deep-dive on multi-agent crews with typed inter-agent communication.

MCP spec v1.2: tool output schemas now required — Servers must now declare the shape of what they return, not just inputs. Aligns MCP directly with the Pydantic AI pattern: typed contracts all the way down.

LangChain's "TypedChain" API — Looks suspiciously like Pydantic AI. The ecosystem is converging. If you're starting a new agentic project today, a typed-contract-first framework is the right foundation.

@joaomdmoura (CrewAI founder): "Typed task outputs are the single biggest reliability improvement we've shipped"

Most multi-agent failures aren't model failures — they're interface failures. When Agent A passes unstructured text to Agent B, B is doing implicit parsing on every run. Typed contracts eliminate that entire failure surface. CrewAI 0.9 makes Pydantic models first-class output types for any task in a crew. via @joaomdmoura on X

@hwchase17 (LangChain): "Agents need memory systems, not just context windows"

Context window expansions solve the wrong problem for agentic workflows. What you need is selective, structured retrieval — not "shove everything into 200K tokens." LangGraph's memory store is their answer. Worth comparing against the Mem0 approach (persistent user-level memory across sessions). via @hwchase17 on X

Google DeepMind ships A2A v0.3: standardized agent handoff protocol

The spec now includes a trust negotiation layer — agents can declare capabilities and require auth tokens for sensitive operations. 23 companies now have working A2A implementations. The agent-to-agent economy isn't hypothetical anymore. via DeepMind Engineering blog

Building a typed multi-agent pipeline that actually works in production

The pattern: define a Pydantic model for what each task produces, declare it as the output_pydantic of that task, and CrewAI handles validation + retry. The downstream agent receives a typed object, not a string. Here's the core pattern: The context=[research_task] line is where the magic happens — CrewAI serializes the validated ResearchFindings object and injects it into the analyst's prompt as structured context. No string munging. Type-safe all the way down.

Best local AI rig for running a full multi-agent crew — under $800

The goal: run a 3-agent CrewAI crew locally, each agent using a 14B-class model, under 24GB VRAM total. This is the sweet spot for full privacy and zero API costs.

• GPU: RTX 4070 Ti Super (16GB VRAM) — ~$420 used on eBay
• CPU: Ryzen 7 5700X — ~$120
• RAM: 32GB DDR4 3600 — ~$60
• SSD: 1TB NVMe + Motherboard + PSU — ~$160
• Total: ~$760 — runs Qwen2.5-14B-Q6_K at 45 tokens/sec

Anthropic releases Claude Code SDK with full MCP support — Programmatically control Claude Code as an agent worker. Give it a GitHub MCP and a task description, let it write + commit code while other agents handle research and planning. This is the autonomous engineering workflow.

Mem0 raises $10M — long-term memory for agents is a real product category — Gives agents persistent memory across sessions: user preferences, past decisions, accumulated context. The architecture (vector store + graph + key-value) is worth understanding even if you roll your own.

MCP hits 2,000 community servers — Two months ago it was 1,200. The growth is compounding. Check the registry before building any new integration for your agents — there's a good chance someone already built it better.