NVIDIA NOOA vs LangGraph: When Your Agent Should Be a Python Class, Not a Graph
Two open-source ways to build an agent, two opposite bets. LangGraph makes it a graph of nodes and edges you wire explicitly. NVIDIA's NOOA makes it a single typed Python class. Here's the axis-by-axis comparison — control flow, state, audit, memory, and speed — and a straight answer on which one your project should pick.
5 min
Alibaba's AI Coded for 16 Days Straight. The Model Didn't Do That — the Harness Did.
Qwen3.8-Max's headline demo — 16 days, 265 commits, 127 PRs, every commit auditable on GitHub — is real and worth studying. But the thing that survived 16 days wasn't the model; it was a state machine, a watchdog, and a CI gate wrapped around a model that remembers nothing between steps. That harness is the part you can build on a far cheaper model.
5 min
The Founder's Wire, August 6: The Safety Framework Nobody Can Read, and the Open Weights That Answer It
This week the White House finalized a voluntary frontier-model testing framework — behind closed doors, and it hasn't shown the text to industry. In the same stretch, a fourth trillion-scale open-weight model landed. The throughline for founders: capability keeps getting more downloadable while oversight gets more private.
4 min
The Founder's Wire, Week of August 6: Anthropic Ships an Enterprise DLP Layer, Microsoft's Agent Harness Hits GA, and the Agent Stack Grows a Control Plane
No headline model dropped this week. The money moved into the plumbing instead — a governance layer that vets prompts before the model sees them, a hosting runtime that reached GA, and a standard that crossed 400M monthly downloads. For a team of one, your moat is shifting from which model to which control plane.
4 min
The US Finalized Its Voluntary AI Safety Framework: What's In It, What's Left Out, and What Founders Should Do
The White House closed the loop with a dozen AI labs on August 4. The framework is real, it's voluntary, and it hands the government up to 30 days of pre-release access to the most capable models. For a solo founder the rules barely touch you — but the three things deliberately left out will shape your access and your future compliance bill.
4 min
The White House AI Framework Is Final. Does It Regulate Your Startup? Almost Certainly Not — Here's the Part That Does.
On August 3–4, a dozen labs met the White House to 'close the loop' on a voluntary framework for frontier models. If you build on models instead of training them, it doesn't touch you directly. The Gold Eagle clearinghouse is the part that reaches down to your stack.
4 min
Project Think vs the Agents SDK vs LangGraph: Choosing a Long-Running Agent Runtime
Three ways to run an agent that lives longer than one request — and they disagree on one axis: how much of the loop you write yourself. The right pick follows how much control you want and whether the agent must run anywhere but Cloudflare.
4 min
LangGraph's Store vs Mem0: Build Your Agent's Long-Term Memory, or Buy It?
Both give an agent memory that survives across sessions. One is a primitive you write to; the other is a layer that decides what to remember for you. That single difference — who does the extraction — is the whole decision, and it's the one the comparison tables never name.
4 min
LangChain 1.5 Gave You One reasoning_effort Knob for Every Model — and It's a Trap
A single standard parameter now sets reasoning effort across OpenAI, Anthropic, xAI, and Fireworks. It's portable. It is not equivalent — 'medium' means a fixed gear on one provider and half your token budget on another.
4 min
How to Give Your Agent Persistent Memory on Cloudflare, Without Running a Database
A copy-paste walkthrough: the Cloudflare Agents SDK puts each agent in its own Durable Object — its own compute plus its own SQLite file — so memory lives inside the agent at the edge, with zero infrastructure to run.
5 min
Foundry Hosted Agents Hit GA: Bring Any Harness, Get a Per-Agent Identity, Pay by the vCPU-Hour
Microsoft made Foundry's hosted agents generally available — and the interesting part isn't the runtime. It's that the old 'which framework?' decision is finally decoupled from 'where does it run?', and every deployed agent now gets its own Entra identity. Here's what actually changed for a solo builder, what it costs, and where the lock-in hides.
3 min
From Empty Folder to Deployed Agent: Google's Agents CLI, Command by Command
Google's Agents CLI shipped August 3. Here's the whole loop — install, scaffold, run locally, evaluate, deploy, publish — with the real commands, so you can take an ADK agent from an empty folder to a Google Cloud runtime in one sitting.
4 min
The US Won't Tell You What's In Its AI Rules. The EU Will. What the Split Means for What You Ship
This week the two biggest AI markets finalized opposite bets. The White House met the top labs on August 4 with a safety framework it finished on August 1 and won't publish. Two days earlier, the EU's transparency duties switched on — binding, specific, and public. For a solo founder, only one of these is a checklist you can act on today; the other is a black box that still moves your release calendar.
4 min
Microsoft Agent Framework 1.13: Reusable Session Stores Land the Same Fortnight MCP Went Stateless
python-1.13.0 and dotnet-1.16.0 shipped July 30 with reusable session stores and full Foundry Responses persistence. The timing is the story: the protocol just pushed state out, and the framework is picking it up.
5 min
How to Redeploy a Long-Running LangGraph Agent Without Killing In-Flight Runs
Ship a new version while an agent is three tool-calls deep and the default outcome is a dropped run. LangGraph 1.2's graceful drain stops at a clean boundary and leaves a checkpoint you can resume — but only if you wire the SIGTERM path yourself.
4 min
Microsoft Agent Framework 1.13 Ships: The Release That Makes a Crashed Agent Resumable
python-1.13.0 and dotnet-1.16.0 landed July 30. The headline isn't a smarter agent — it's reusable session stores and checkpoints that replay from the original input *and* the human approvals, so a long run survives a restart without asking your operator twice.
4 min
Your Coding Agent Forgets Everything Every Session. The Fix Is a Progress File and a Git Log.
Anthropic's harness for agents that run for hours doesn't add memory to the model. It writes the state to disk — a progress file, an init script, and a commit per feature — so a fresh context window can read where the last one stopped.
5 min
Vercel AI SDK 7 vs LangGraph 1.0: Which Agent Runtime for a TypeScript Team in 2026
AI SDK 7 turned Vercel's model wrapper into a full production agent runtime — three agent types, approvals, durability. LangGraph is still the graph you build the loop on. The choice is TypeScript-native convenience versus explicit control.
4 min
Tool Highlight: NOOA — NVIDIA's Object-Oriented Agent Framework Makes an Agent Auditable by Design
Most agent frameworks bolt tracing on after the fact. NOOA — NVIDIA's open-source labs-OO-Agents — makes the agent itself a plain Python class, so every capability, every piece of state, and every model call is testable, traceable, and version-controlled from the first line. It's the harness-layer piece of the new Open Secure AI Alliance.
3 min
How to Ship a Production Agent With Bedrock AgentCore Harness in Two API Calls
A copy-paste walkthrough from an empty boto3 session to a running, tool-using agent — you declare the model, tools, skills, and instructions, and AWS runs the loop. No orchestration code.
4 min
Declarative Agent Harness vs Hand-Written Loop: Which Should a Founder Ship?
Managed harnesses like AgentCore let you declare an agent and rent the loop; the Claude Agent SDK and its kin let you own it line by line. The right call isn't about AWS — it's about where your product's edge actually lives.
4 min
Build on an Open-Weight Frontier Model, or Wait? A Founder's Bet-or-Wait Framework
Reflection, Kimi K3, GLM — the open-weight frontier is getting loud, and it's tempting to make one of these models load-bearing in your product. Before you do, run the bet through four gates: is it shipped, is it callable, what's the license, and what's your fallback. Here's the framework, with the three staging patterns that let you get the upside without betting the company.
3 min
Pydantic AI V2 vs LangGraph: A Bundle of Capabilities, or a Graph You Wire Yourself
Pydantic AI's V2 rewrite bets the whole framework on one primitive — the capability — and hides the loop. LangGraph makes the loop the product: nodes, edges, and a checkpointer you own. Here's which bet fits which team.
5 min
The Founder's Wire, Week of July 28: After the Launch — the Harness, the Node, and the License Fine Print
The previews are over. The MCP spec is final today, Kimi K3's weights and numbers are both public — and the honest story in each is the part the launch posts skipped: a harness caveat, a single-node self-host, and a license that isn't MIT.
4 min
Clear, Compact, or Remember? The Cross-Vendor Decision Framework for Long-Running Agent Context
Anthropic ships three levers for a context window that fills with junk — clearing, compaction, and memory. OpenAI and LangGraph have the same three, under different names. Here's which to reach for, and where each vendor's version differs.
6 min
Cloudflare's Agents SDK Now Runs AI SDK v6 and v7 — So Updating No Longer Forces a Migration
A July 23 release widened the peer range to ai@^6 || ^7 across four packages. You can finally patch the Agents SDK for fixes and features without being dragged onto Vercel AI SDK 7's breaking changes.
3 min
Harness Shipped an SDLC for Agents: 'Build, Test, Deploy, Govern' When the Code Is Non-Deterministic
On July 21, Harness put five new products around the AI agent lifecycle — evals as quality gates, prompts behind feature flags, OpenTelemetry traces, deployment governance. The bet is that agents ship through the same pipeline as your code.
4 min
Go Just Got Two First-Party Agent Frameworks — and OpenAI and Anthropic Still Ship Neither
Microsoft's Agent Framework for Go hit public preview weeks after Google's ADK for Go matured. The model labs whose APIs you actually call haven't followed. Here's what that split means for your backend.
4 min
MCP Tools as First-Class LangGraph Nodes: When It's Worth Rewriting Your Graph
LangGraph 1.0 is stable and durable — but the real MCP win is treating each tool as its own graph node. Most builders should not rewrite. Here's the line.
4 min
How to Build an Event-Driven Agent with LlamaIndex Workflows 1.0
From an empty file to a running fan-out-and-join agent in one sitting — using the minimal event bus that shipped stable on June 22, 2026. Copy-paste the steps, then swap in your own model and tools.
3 min
CrewAI Flows vs LlamaIndex Workflows: Which Event-Driven Orchestrator Should a Founder Build On?
Both let you own the control flow instead of renting a black-box agent loop. The choice comes down to one question — is the hard part your org chart of agents, or the events between your steps?
4 min
Build an AI Agent From Scratch: The Loop That Replaces a Framework
An AI agent is a while-loop around one model call. Here's the ~90 lines of Python that does what LangGraph does for an MVP — and the three seams where a framework starts to earn its keep.
6 min
Put a Production Streaming UI on Your LangGraph Agent With the Rewritten @ai-sdk/langchain
Keep LangGraph for orchestration, get a React streaming chat for free. The rewritten adapter turns a graph stream into an AI SDK UIMessage stream in a few lines.
5 min
Pydantic AI v2.14 Made Crash-Proofing a Capability — and Deprecated the Wrapper Agents
The July 20 release folds durable execution into the same 'capabilities' system V2 introduced. Temporal, DBOS, and Prefect now attach in one line — and the wrapper-agent classes you may have shipped are on the way out.
4 min
Self-Host Your Agents or Rent Them? What NVIDIA + LangChain's NemoClaw Blueprint Changes for a Founder
The July 8 NemoClaw blueprint makes self-hosting open agents a real option — but for a team of one, the deciding factor is token volume, not vendor benchmarks.
5 min
Microsoft Agent Framework 1.12 Ships Today: Native MCP Hosting and Persistent Cosmos Memory
The Python 1.12 and .NET 1.14 releases landed July 21 — and the headline isn't a new agent trick. It's that your agent becomes an MCP server, and its memory stops dying with the session.
4 min
How to Upgrade LangGraph Streaming: From Dict Events to v2 Typed Parts and v3 Projections
LangGraph 1.2 shipped two new streaming APIs on top of the old stream_mode dicts. Here is what version="v2" and version="v3" actually change, and which one to reach for.
4 min
How to Define a CrewAI Flow in YAML: Declarative Flows Without the Python
CrewAI 1.15 lets you describe a whole multi-agent flow in a config file — here's the minimal shape and how to run it.
4 min
Hermes Agent's 'Quicksilver' Spent 2,245 Commits on Speed and Trust — Not a Smarter Model
v0.19.0 (July 20) cut first-turn time-to-first-token ~80%, streams reasoning live, and adds an independent-LLM approval reviewer and a crash-proof delivery ledger. The coding-agent race is being run on the harness, not the model.
4 min
Microsoft Shipped an Agent Framework for Go — the Go Field We Mapped Last Week Just Got a Vendor Heavyweight
A day after we argued Go teams rarely need an agent framework, Microsoft put a first-party one into public preview. Here's what it covers, what it's still missing, and when a founder should reach for it instead of a forty-line loop.
4 min
Make Your OpenAI Agents SDK Agent Survive a Crash: Temporal, activity_as_tool, End to End
Temporal now ships a first-class OpenAI Agents SDK integration inside its Python SDK. Wrap your tools as durable activities, run the SDK's own Runner inside a workflow, and a mid-run crash resumes from the last completed step instead of starting the LLM loop over.
4 min
Code Mode, Three Ways: GPT-5.6 vs Claude vs Pydantic AI CodeMode for Tool-Heavy Agents
Three vendors shipped the same idea within weeks — let the model write code that orchestrates your tools instead of round-tripping one JSON call at a time. Here's what actually differs, and which one to reach for.
4 min
Microsoft Agent Framework 1.11 Lets You Nudge a Running Agent Mid-Turn
The July release adds message-injection middleware — host code or a tool can drop a message into a live run and have it picked up on the next model call. Skills also left experimental. Here's what actually changed and why the mid-turn hook matters for long-running agents.
3 min
LangChain 1.0 Middleware vs. LangGraph Nodes: Where to Put Your Agent Logic
Both ship on the same runtime — middleware is sugar over a LangGraph graph. The decision isn't which framework; it's which layer. Here are the real hooks, the real node API, and a clean rule for choosing.
3 min
How to Give a CrewAI Crew Governed Access to Snowflake — via the Managed MCP Server
Snowflake now ships its own managed MCP server, so your CrewAI agents can query the warehouse in natural language without a connector, a warehouse password, or a single line of glue. Here's the exact wiring — and why the security boundary moves into Snowflake's role model.
4 min
Resume a Crashed LangGraph Run: A Hands-On Guide to Checkpointers and thread_id
A LangGraph agent that dies mid-run doesn't have to start over. Compile with a checkpointer, invoke with a stable thread_id, and the graph rehydrates from its last checkpoint. Here's the copy-paste path from MemorySaver to Postgres.
4 min
Pydantic AI V2 vs V1: Migrate Now, or Ride Out the Maintained V1?
V2 landed in June as a harness-first rewrite around one new primitive. V1 isn't dead — it's in long-term maintenance and still shipping security fixes. Here's how to decide which line your agent belongs on.
4 min
Microsoft Agent Framework Made Skills Stable and Shipped a Way to Nudge a Running Agent Mid-Turn
The July releases graduated the Skills API out of experimental and added message-injection middleware — you can now correct a live run without killing it. Here's what actually shipped and what it changes.
4 min
CrewAI Flows Control Flow: Run Steps in Parallel and Branch with @router, and_, or_
Flows give you an event-driven graph without writing threading or a state machine. Here's the whole control-flow vocabulary — @start, @listen, @router, and_, or_ — with copy-paste code for fan-out, join, and conditional branching.
5 min
How to Give a CrewAI Crew Shared, Cross-Session Memory with Mem0
CrewAI's built-in memory resets every run and lives in a local SQLite file. This is the copy-paste walkthrough for swapping in Mem0 so a crew remembers a user across sessions — both the managed Cloud path and the self-hosted OSS one.
4 min
Make Your CrewAI Flow Survive a Crash: A Hands-On Guide to @persist
A multi-agent run that dies at step 4 shouldn't restart at step 1 — and pay for steps 1–3 again. Here's the copy-paste code to checkpoint Flow state, kill the process, and resume exactly where it stopped.
6 min
CrewAI 1.15 Made Flows Declarative: What FlowDefinition and Token Aggregation Change for Founders
The 1.15 line moved flow authoring from decorated Python classes toward data you can load, version, and review — plus one small feature that finally answers 'what did this agent run cost me?' Here's what actually shipped and whether it's worth the upgrade.
4 min
Tool Highlight: CrewAI — Give Each Agent a Role, Then Let the Crew Do the Work
One model doing everything is hard to steer. CrewAI lets you split a job across a crew of role-specialized agents — a researcher, a writer, a reviewer — and orchestrate how they hand work to each other, in plain Python.
3 min
How to Cap Your Agent's Token Bill in Pydantic AI v2.9: usage_limits, the /usage Command, and Budget-Aware Tools
Pydantic AI v2.9 shipped a /usage command for cumulative token tracking and — the real upgrade — exposed the run's usage_limits to your tools. Here's how to set a hard budget, read what's left from inside a tool, and stop a runaway agent before the bill lands.
5 min
Your Agent's Message History Is an Injection Surface: Pydantic AI v2.5's sanitize_messages, Explained
When a browser client sends the conversation back to your agent every turn, it can smuggle in a system prompt, a rogue file URL, or a dangling tool call. Pydantic AI v2.5 ships the sanitizer — and shipped one subtle bug worth understanding.
4 min
OpenAI Agents SDK 0.18: Hosted Multi-Agent Beta Lands — What Shipped, and When to Still Self-Host
In three releases across five days, the OpenAI Agents SDK made GPT-5.6 the default and quietly added 'hosted multi-agent beta support' — a path to run agent fan-out on OpenAI's infrastructure instead of your own. Here's what's actually in 0.18, and the decision it forces.
4 min
Microsoft Agent Framework Shipped Progressive MCP Disclosure: discover / load / unload for Your Tool Budget
Microsoft's agent framework now lets an agent pull MCP tool schemas in on demand instead of front-loading all of them. It's the tool-search fix — and it means the big three frameworks now agree on the shape.
5 min
How to Let Your Agent Talk to Agents You Don't Own: A2A in Microsoft Agent Framework
Microsoft Agent Framework 1.0 ships native A2A support. Here's how to consume a remote agent in three lines — and expose yours so other people's agents can call it — with code.
3 min
Gating a Tool Call Behind Human Approval: 3 SDKs, Side by Side
The minimal code to pause a tool call for human sign-off in LangGraph, the Vercel AI SDK, and the OpenAI Agents SDK — and the one design choice that actually matters.
4 min
The Agent Stack Just Consolidated: 6 Founder Signals From June–July 2026
In six weeks the default agent framework, the open-weight coding tier, and the first identity standard all moved at once. Here's what changed and what to do about each — skimmable, sourced.
4 min
The Founder's Shipping Log: What Landed in AI Agent Frameworks This Quarter
Seven agent-framework releases from Q2 into July 2026, each in two lines: what shipped, and what it changes for a founder who has to build on it.
5 min
Microsoft Agent Framework 1.0 vs Pydantic AI V2 vs LlamaIndex Workflows: Picking Your 2026 Agent Stack
Three frameworks, three bets on what an agent actually is — a protocol-native orchestration layer, a typed harness you compose, or an event-driven workflow graph. The right pick depends on what you're optimizing for, not which one launched most recently.
4 min
Microsoft Agent Framework vs LangGraph vs OpenAI Agents SDK: Which to Bet On in 2026
Three production frameworks now anchor the agent stack, and they disagree about the one thing that matters: who holds control when a run goes sideways. Pick by that, not by the feature list.
4 min
Microsoft Agent Framework vs LangGraph vs CrewAI: Which One Crossed the Three Thresholds
Three thresholds separate a production agent framework from a demo — durable state with human-in-the-loop, native MCP, and native A2A — and in mid-2026 only one of these three clears all three in-box.
5 min
Agent Framework's Five Orchestration Patterns: Which One for Your Multi-Agent App
Sequential, Concurrent, Group Chat, Handoff, Magentic. The real question every pattern answers is the same one — who decides which agent goes next — and the answer trades control for autonomy.
4 min
How to Add Per-Node Timeouts to a LangGraph Agent So One Slow Tool Doesn't Hang the Run
A single node waiting forever on a stuck API is the most boring way an agent dies. LangGraph 1.2 gives you two kinds of timeout — and picking the wrong one silently kills your streaming nodes.
4 min
Pydantic AI CodeMode: Run Ten Tool Calls in One Model Turn
The Harness ships a capability that collapses a whole loop of tool calls into a single sandboxed Python script the model writes once. Here's the two-line change, what it actually does, and when it pays off.
3 min
Microsoft Agent Framework vs LangGraph vs Claude Agent SDK: The Founder's Agent-Stack Pick
Microsoft folded Semantic Kernel and AutoGen into one production framework and shipped it for .NET and Python. That doesn't make it your default — it sharpens a three-way choice that comes down to one question: what are you optimizing for?
3 min
Building a Typed Agent with Pydantic AI V2
A from-scratch, code-heavy walkthrough: a typed output model, tools with @agent.tool, dependency injection, sync/async/streaming runs, and what V2's capabilities model actually changes in the code you write.
6 min
How to Test an LLM Feature Before You Ship It (a Minimal Eval Harness You Can Build in an Afternoon)
You wouldn't ship a payments flow with zero tests. Most teams ship LLM features with exactly that. Here's the smallest real eval harness — deterministic assertions plus an LLM-as-judge — with copy-paste promptfoo and Python.
7 min
LlamaIndex Workflows 1.0: The Orchestration Engine Left the RAG Framework Behind
The headline reads like a version bump. It isn't. Workflows 1.0 is the moment LlamaIndex's event-driven engine became a package you can install with no LlamaIndex in its dependency tree — and that changes what "using LlamaIndex" means.
4 min
Go AI Agent Frameworks: Eino vs LangChainGo vs Genkit (and When to Skip the Framework)
In Python, an agent framework sells you concurrency, cancellation, and retries. Go ships all three in the standard library — so the real question in Go isn't which framework, it's whether you need one.
5 min
LangChain's Deep Agents Now Ships Its Own Coding Agent — and Speaks ACP
In early July, Deep Agents quietly split into three shippable packages: a model-agnostic harness, a terminal coding agent, and an ACP adapter. The library became a product line — and unbundled the coding agent from both the model and the editor.
4 min
CrewAI Conversational Flows: What 'Chat' Actually Adds to a Crew
CrewAI 1.15 shipped conversational flows, and it's easy to read that as "your crew can hold a conversation now." It can't. What shipped is a persisted, resumable flow behind a poll loop — and that distinction decides how you build.
4 min
Pydantic AI V2 Quietly Repointed `openai:` at the Responses API — What Actually Breaks
V2's headline is the Harness. The change that will page you is smaller: the bare `openai:` prefix now resolves to a different OpenAI API, and no deprecation warning fires.
4 min
OpenAI Agents SDK Run Error Handlers: Catching Model Refusals and Invalid Structured Output
v0.17.8 added an `invalid_final_output` handler — a third failure layer that catches what the model itself produces at final output, not what your tools or guardrails do.
5 min
LangGraph Deferred Nodes: Getting Map-Reduce Fan-In Right
The Send API gives you the fan-out. Deferred nodes are how you get a correct fan-in — but only if you understand that defer=True is a queue-drain barrier, not a dependency resolver.
4 min
LangGraph Checkpointer: Postgres vs Redis Backend Comparison
Choosing a checkpointer backend isn't a speed decision. It's a decision about what lifecycle you want your agent's state to have — a permanent ledger you can replay, or a searchable cache built to expire.
4 min
Making a Pydantic AI Agent Crash-Proof: Temporal vs DBOS vs Prefect vs Restate
Pydantic AI now speaks four durable-execution backends with near-identical code. That means the choice isn't about the framework — it's about which piece of infra you're willing to run.
4 min
Omnigent: Databricks' Meta-Harness for Running Claude Code, Codex, and Cursor as One Layer
Databricks open-sourced a common orchestration layer over Claude Code, Codex, Cursor, and your own agents — swap the harness in one line of YAML. The interesting bet isn't portability. It's who reviews the code.
5 min
LangGraph Node Timeouts: run_timeout vs idle_timeout for Agent Nodes
LangGraph 1.2 shipped per-node timeouts with two knobs that look interchangeable and aren't. Pick the wrong one and you either kill healthy slow work or never catch the hang you added it for.
5 min
LangGraph's DeltaChannel: The Checkpoint Cost That Scales With Your Thread
Every superstep, the default channel re-serializes your entire message list into the checkpoint. On a long-running agent, that write cost grows with the conversation — and DeltaChannel is the fix that finally makes it linear.
6 min
ADK 2.0 Turns Agents Into Graph Nodes: Inside Google's Workflow Runtime
Google's Agent Development Kit shipped a graph-based execution engine — and quietly retired the org-chart of agent types that used to be its whole pitch against LangGraph.
4 min
The Quiet Default Flip: Agent Frameworks Now Ask Before They Act
In mid-2026 the three biggest agent frameworks converged on the same primitive — tool calls gated behind a human approval — and Microsoft made it the default for anything a skill brings in. It's the security fix sandboxing couldn't provide.
6 min
LangGraph's DeltaChannel: The Hidden Quadratic Cost of Durable Agents
Every checkpoint a long-running LangGraph agent writes re-serializes its entire state. DeltaChannel, per-node timeouts, and the v2 stream in 1.1–1.2 are the runtime quietly admitting the naive durability model doesn't scale.
4 min
CrewAI 1.14's Pluggable Backends: The Framework Is Un-bundling Its Storage
CrewAI 1.14 lets you swap the default memory, knowledge, RAG, and flow backends for your own. It reads like a config change. It's actually the framework conceding that batteries-included storage was a production liability.
4 min
LangGraph Platform Is Now LangSmith Deployment — and Your Agent Ships as an MCP Server by Default
The rename reads like marketing housekeeping. It isn't. Folding deploy into LangSmith and handing every deployed agent an MCP endpoint quietly reclassifies your agent from an application into a tool other agents can call.
4 min
CrewAI Flows vs Crews: When to Let Agents Decide and When to Script Them
CrewAI ships two orchestration models in one framework. Picking wrong is why your multi-agent demo worked and your production run didn't — and the fix is usually not choosing between them.
4 min
Agent Framework Token Costs, Compared: Why the Same Task Can Cost 2–3× More on CrewAI
Independent 2026 benchmarks running the identical task on the identical model find the framework alone can double or triple the token bill. The number you can't see on the invoice is the one the framework spends on your behalf.
5 min
OpenAI Agents SDK vs LangGraph: Two Frameworks Answering Different Questions
The usual framing is 'simple handoffs vs powerful graphs.' That's the wrong axis. One framework asks who is in charge right now; the other asks what shape the computation has — and they fail from opposite directions as you scale.
5 min
Deep Agents on Pydantic AI: The Repos for a Self-Hosted, Model-Agnostic Claude Code
Claude Code proved the 'deep agent' pattern — planning, a filesystem, sub-agents, skills. A small cluster of Python repos now rebuilds that harness on Pydantic AI, so it runs on any model you own.
4 min
AgentScope vs LangGraph: Two Production Frameworks Built Around Different Fears
Alibaba's AgentScope hit 2.0 and calls itself production-ready; LangGraph has owned that word for a year. They converge on the same job from opposite origins — and the real choice is which failure you're more afraid of.
4 min
Vercel AI SDK 7: Durable Execution and Tool Approvals Move Into the SDK
The headline in AI SDK 7 isn't a new agent class. It's that durability and human approval stopped being things you bolt on and became primitives — at the cost of an ESM-only, Node 22+ upgrade.
4 min
Microsoft Agent Framework's CodeAct: When the Sandbox Stops Being the Hard Part
Code-execution agents always ran into the same wall — running model-written code safely is expensive. Hyperlight's sub-2ms micro-VM moves that wall, and changes what the pattern costs.
5 min
Pydantic AI V2 Is Out: What 'Capabilities' and the Harness Actually Change
V2 went stable on June 23 after seven betas, then shipped four releases in nine days. The real news isn't the version bump — it's a bet that the winning agent abstraction is a harness, not a graph.
5 min
Pi's System Prompt Is Under 1,000 Tokens: The Case Against Heavy Coding-Agent Harnesses
Most coding agents open with a ~10,000-token system prompt. Pi opens with under 1,000 and lets the model write its own tools. The bet underneath: the model already knows how to be an agent, and every instruction token is a task token you don't get back.
4 min
Agent Handoffs in LangGraph, OpenAI Agents SDK, and Google ADK: What Actually Transfers With Control
Every multi-agent framework now has a handoff primitive, and they all look the same in the demo. The difference that bites you in production is what rides along when one agent passes the baton to the next.
5 min
Every AI Agent Framework Became a Graph in 2026 — and the Hard Part Is Still Unsolved
With ADK 2.0's GA, LangGraph, OpenAI's Agents SDK, Google's ADK, and Microsoft's Agent Framework all now run on a graph execution engine. The programming model war is over. It settled the easy question.
5 min
Declarative Agents: When a YAML File Should Define Your Agent — and When It Can't
Microsoft and Google both now let you define an agent in YAML instead of code. The split isn't about simplicity — it's about whether your agent's logic lives in its wiring or in its decisions.
5 min
Vercel eve vs Microsoft Agent Framework: Portable Agent, or Portable Runtime?
Both shipped the same six production features in 2026. The choice isn't capabilities — it's which half of your agent you're willing to lock to a vendor.
5 min
LangChain 1.0 and LangGraph 1.0: What Actually Changed for Agent Builders
After a year of churn that made it a punchline, LangChain shipped a 1.0 whose headline feature is the thing frameworks never promise: that it will stop moving under you.
4 min
Claude Agent SDK vs OpenAI Agents SDK: A Harness vs an Orchestration Library
Both vendors shipped an official agent SDK, so the choice looks like a feature bake-off. It isn't. They sit at different layers and bet on different hard parts — and their defaults decide which one your problem is one line of code away from.
5 min
Vercel eve vs LangGraph: Library You Host, or Harness You Rent
Vercel's new agent framework treats an agent as a directory of files. LangGraph hands you a portable graph. The decision isn't the loop they run — it's who owns the production stack wrapped around it.
5 min
Microsoft Agent Framework at Build 2026: Agent Harness, Hosted Agents, and CodeAct
Microsoft stopped shipping orchestration patterns and started shipping the runtime underneath them. The three Build 2026 launches are all below the framework — and one of them quietly retires the JSON tool-call loop.
4 min
LangChain vs LangGraph vs Deep Agents: Pick a Rung, Not a Framework
Deep Agents isn't a fourth framework competing with LangChain and LangGraph — it's a preset of LangChain middleware on the same runtime. The choice is how much opinion you want pre-assembled.
5 min
Hermes Agent: What 'Self-Improving' Means When the Model Never Changes
Nous Research's Hermes is the agent everyone's calling self-improving. It is — but the part that improves isn't the model. It's the harness writing its own skills.
4 min
Harness Engineering: The Reliability Layer Around an Unreliable Model
Prompt engineering tuned the words. Context engineering managed the window. The discipline that decides whether an agent ships is the deterministic code around the model — and it is older than it looks.
5 min
LangGraph vs Microsoft Agent Framework: Who Owns the Run Loop in 2026
They ship the same orchestration patterns now, so stop comparing them on patterns. The real fork is where your production agent actually runs — in code you hold, or in a cloud you rent.
4 min
Strands Agents vs LangGraph: Who Drives the Agent Loop
AWS's Strands lets the model plan its own path; LangGraph makes you draw the path first. The choice isn't graph versus no-graph — it's how much you trust the model to drive.
4 min
Spring AI vs LangChain4j: Which Java Framework for Your LLM App?
Both Java AI frameworks hit 1.0 the same week and both now do RAG, tools, MCP, and observability. The real choice isn't features — it's where your app's center of gravity already sits.
4 min
LlamaIndex Workflows vs LangGraph: Event-Driven vs Graph Agent Orchestration
One framework makes you draw the control-flow graph up front; the other lets it emerge from events. Pick by whether your hardest requirement is durable recovery or flexible composition.
5 min
Genkit vs LangChain vs Vercel AI SDK: Which GenAI Framework Should You Build On?
Google's Genkit is the framework that bundles the parts the others sell separately. The real choice isn't features — it's where your code runs and how much of your ops you want the framework to own.
5 min
Cloudflare Agents vs LangGraph: Where Your Stateful Agent Actually Lives
They both promise durable, resumable agents — but one is a place to run code and the other is a way to structure it. Confusing the two is how teams end up with neither.
5 min
OpenAI AgentKit vs LangGraph: Why the Visual Builder Got Deprecated First
OpenAI shipped a drag-and-drop agent canvas in October, then posted its deprecation notice eight months later. The part that survived tells you which layer to build on.
4 min
LangGraph Checkpointing vs Temporal: Why Checkpoints Aren't Durable Execution
Most teams assume LangGraph's checkpointer already makes their agents crash-proof. It doesn't — and the gap is architectural, not a missing setting. Here's exactly where it ends and where Temporal begins.
4 min
LangChain Agent Middleware, Explained
LangChain 1.0 reduced the agent to two lines and moved everything interesting into hooks. The quiet consequence: supervisor, swarm, and reflection stop being architectures and become middleware you stack.
4 min
Google ADK vs LangGraph: Which Agent Framework Should You Build On in 2026?
Both will run the same agent. The real difference is altitude — ADK hands you an org chart of agents, LangGraph hands you the wiring and a roll of tape.
4 min
Dify vs LangChain: Platform or Framework for Your LLM App?
One hands you a finished application to configure; the other hands you parts to assemble. The choice isn't easy-vs-powerful — it's whether your product's hard part lives where the platform already decided.
4 min
Apache Burr vs LangGraph: State Machine or Graph for Your Agent?
Both let you wire an agent as nodes and edges, so they look like the same tool with different syntax. The real split is what each one lets you prove about the thing before it runs.
5 min
AG2 vs AutoGen: Which One Should You Actually Install in 2026?
They share a name, a history, and a lot of code — but by 2026 'AutoGen' splintered into three projects, and the one you pip install decides whose roadmap you inherit.
4 min
Pydantic AI vs OpenAI Agents SDK vs Agno: Choosing a Lightweight Python Agent Framework in 2026
The lightweight, type-first agent frameworks have arrived — and they quietly disagree about how much of your stack a framework should own. Pick on that, not on syntax.
5 min
Semantic Kernel vs AutoGen vs Microsoft Agent Framework: Which One to Build On
Microsoft just deprecated its two most-starred agent frameworks to ship a third. If you're choosing today, the decision is already made for you — here's why, and where it still loses.
4 min
LangChain vs LangGraph: You're Choosing a Layer, Not a Side
Since the 1.0 release, LangChain's agent helper runs on LangGraph's engine — so the real question isn't which to pick, but which layer of the same stack to write against.
5 min
Haystack vs LangChain vs LlamaIndex: Picking a RAG Framework in 2026
All three converged on the same runtime shape, so the old 'which can build an agent' question is dead. What's left is a bet on which layer each treats as first-class — and one differentiator nobody can copy.
4 min
Agno vs LangGraph vs CrewAI: Choosing an Agent Framework in 2026
All three build Python agents, but they disagree on one thing — who owns the loop. That contract, not the benchmark, is what you live with for years.
5 min
smolagents vs LangGraph vs CrewAI: Three Bets on How an Agent Acts
The frameworks that get the most attention disagree on something basic — what an agent's action even is. One writes code, one wires a graph, one casts a team.
5 min
OpenAI Agents SDK vs Pydantic AI vs Google ADK: The New Frameworks, Compared
The second wave of agent frameworks is leaner, typed, and vendor-backed — and underneath the branding, they're quietly converging on the same idea.
5 min
Mastra vs Vercel AI SDK vs LangGraph.js: TypeScript Agent Frameworks in 2026
The three names a JavaScript team keeps hitting when it tries to build an agent aren't competing for the same job. Two of them stack on top of the third.
4 min
Claude Agent SDK vs LangGraph: Inherit a Loop or Own the Graph
One hands you Anthropic's production agent loop already wired up; the other hands you a blank graph and a state machine. The choice is less "which framework" than "how much of the loop do you want to own."
5 min
n8n vs Flowise vs Langflow: Choosing a Visual Agent Builder in 2026
All three give you a drag-and-drop canvas for building AI agents. The choice that actually matters is hidden underneath: what each one thinks it's automating, and whether its license lets you ship it.
5 min
LlamaIndex vs LangChain: Which Framework in 2026, and When Neither Is the Answer
They started on opposite ends — one indexed your documents, one chained your calls. In 2026 they've converged. The real choice is which abstraction you want to debug at 3am.
4 min
LangGraph vs CrewAI vs AutoGen: How to Choose an Agent Framework in 2026
All three claim to build multi-agent systems. The real question isn't features — it's who owns the control flow, and the answer changes which one is the right call.
4 minLatest in Agent Frameworks
Not buyer's guides — the news, teardowns, and explainers behind this topic.
LangGraph Node Error Handlers: Saga Compensation, and Why It Isn't a Timeout
LangGraph 1.2 gives a node three ways to fail — timeout, error_handler, drain. They look similar and do opposite things to your state. Mixing them up corrupts compensation.
4 min
Langflow Is the First AI-Agent Platform in CISA's KEV — and Both Ways In Reach the Same Loot
An unauthenticated RCE and an authenticated cross-tenant IDOR are opposite bug classes. In Langflow they end the same way: a prompt that says 'leak api keys.'
4 min
From Framework to Harness
The agent libraries that mattered in 2024 told the model what to do next. The ones that matter now assume it already knows — and sell you the restraints and the trace instead.
4 min