What to learn, build with and skip in AI agents (2026)

What to learn, build with and skip in AI agents (2026)
5questions to filter any launch
7concepts that compound over time
8steps to adopt agents without getting lost
6months: the window to know whether something new matters
What to learn, build with and skip in AI agents (2026)
I also explain it in this video, on my channel Articulator EN. The figures in this post are frames from the video.

Signal and noiselink

Every day brings a new framework, a new benchmark and another launch promising ten times more. The question stops being "how do I keep up?" and becomes "what is actually signal here, and what is noise wearing the costume of urgency?".

Any roadmap goes obsolete a month after it comes out. The framework you mastered last quarter is already legacy, and the benchmark you optimized for got gamed and replaced. We were taught a slow path (topics by level, job titles, years of tenure) and AI rewrote it: with good prompts and good taste, anyone can now ship what used to take an engineer with two years of experience a sprint.

Experience still matters. Nothing replaces having watched systems break, having debugged a memory leak at 2am or having argued for the boring choice over the clever one, and being right. That judgment compounds. What no longer compounds is knowing this week's framework's API surface, which will be different in six months.

The field has no destination yet, either. The big labs iterate in public, ship regressions and patch them live. According to the author, the Claude Code team shipped a version that was 47% worse, and it was users who caught it. Nobody has the map, and that changes the question of credentials: between a 22-year-old posting agent demos and a 35-year-old senior engineer there are no longer ten years of advantage. Both have the same blank canvas, and what adds up for them is shipping things and mastering a few building blocks that do not expire.

The filter: five questionslink

You cannot follow every weekly launch, and you should not try. You need a filter, not a feed. The author proposes five questions that have held up for him over eighteen months:

  1. Will this matter in two years? A wrapper around a frontier model, a CLI flag or "Devin but for X": almost never. A primitive (a protocol, a memory pattern, a sandboxing approach): more often yes. Wrappers expire in months; primitives last for years.
  2. Has someone you respect built something real on it and written about it honestly? Marketing does not count; postmortems do. A "we tried this in production and here is what broke" is worth more than ten announcements.
  3. Does adopting it force you to throw away your tracing, retries, config or auth? Then it is a framework trying to be a platform, and those, according to the author, have a 90% mortality rate. Good primitives slot in without forcing a migration.
  4. What does it cost you to skip it for six months? Almost always, nothing: in half a year you will know more and the winning version will be clearer. It is the question that lets you ignore nine out of ten launches without anxiety.
  5. Can you measure whether it helps your agents? If not, you are guessing. Teams without evals run on vibes and ship regressions.
One of the five questions of the filter
Five questions before letting something new touch your system.

If you keep a single habit, make it this one: when something new launches, write down what you would need to see in six months to believe it matters, and come back to check. Most of the time the question will have answered itself.

Underneath there is a skill that is harder to name: being willing to be uncool about what you do not pick up. This week's viral framework will have two weeks of cheerleaders; six months later, half of those frameworks are unmaintained. Waiting, watching and saying "I'll know in six months" is, for the author, the actual professional skill of this field. Everyone can read launches; almost nobody is good at not reacting to them.

Learn: context engineeringlink

What is worth learning are concepts, patterns and the shape of things: ideas that survive model swaps, framework swaps and paradigm shifts. If you understand them, you can pick up any tool in a weekend. The author picks seven, and the first is context engineering.

The rename from "prompt engineering" to "context engineering" is not cosmetic. You no longer write the model a clever instruction: at every step you assemble a working context with instructions, tool schemas, retrieved documents, prior outputs, scratchpad state and a compressed history. The agent's behavior emerges from what you put in that window.

Context is state. Every token of noise costs reasoning quality, and context rot is a real failure: by step eight of a ten-step task, the original goal can be buried under tool output. Teams with reliable agents summarize, compress and prune, version their tool descriptions, cache only what does not change and think about the context window the way a good engineer thinks about RAM.

The context window filling up with noise over the steps
Context is state: every token that does not earn its keep costs you.

His test: turn on full trace logging for an agent in production, look at the context at step one and at step seven, and count how many tokens are still earning their keep. The first time you will be embarrassed; once you fix it, the same agent gets more reliable without touching the model or the prompt. To start, he recommends Anthropic's "Effective Context Engineering for AI Agents" and their multi-agent research system postmortem.

Learn: tool designlink

Tools are where agents meet your business. The model picks a tool by its name and description, retries based on the error message it gets back, and succeeds or fails depending on whether the tool's contract matches what a language model is good at expressing.

  • Five to ten well-named tools beat twenty mediocre ones.
  • Names should read like plain English verb phrases.
  • Descriptions say when to use the tool and when not to.
  • Errors are feedback the model can act on: "Max tokens 500 exceeded, try summarizing first" beats "Error: 400 Bad Request" by a mile.

According to the guide, one team reported 40% fewer retry loops just from rewriting its error messages. The biggest reliability wins, the author insists, are usually tool-side, not in more prompt tuning. His starting point: Anthropic's "Writing tools for agents".

Learn: orchestrator and subagentslink

The multi-agent debate of 2024 and 2025 ended in a synthesis. Naive systems, with several agents writing to shared state in parallel, fail catastrophically because errors compound. Single-agent loops scale further than you would expect. And only one multi-agent shape works in production: an orchestrator that delegates narrowly scoped, read-only tasks to isolated subagents, then synthesizes their results.

An orchestrator handing read-only tasks to isolated subagents
Subagents read; the orchestrator owns the writes.

That is how Anthropic's research system and Claude Code's subagents work: small, focused contexts that cannot mutate shared state. The author recommends reading Cognition's "Don't Build Multi-Agents" alongside Anthropic's "How we built our multi-agent research system": they look like opposites and say the same thing. His advice: default to a single agent; reach for the orchestrator only when you hit a real wall (context window pressure, latency from sequential tool calls, or tasks heterogeneous enough to need separate contexts).

Learn: evalslink

Every team that ships reliable agents has evals; for the author it is the highest-leverage habit in the field and also the most under-invested. What works: harvest your production traces, label the failures and turn them into a regression set that grows with every new failure. LLM-as-judge for the subjective parts, exact-match or programmatic checks for the rest, and the whole suite before any prompt, model or tool change.

Spotify's engineering blog reported that its judge layer vetoes about 25% of its agent's outputs before they ship: without it, one in four bad results would have reached users.

A judge layer vetoing part of the outputs before they ship
An eval is a unit test that keeps the agent honest while everything changes underneath it.

A new model version comes out, the framework ships a breaking change or the vendor deprecates an endpoint, and your evals are the only thing that tells you whether the agent still does its job. The tools (Braintrust, Langfuse, LangSmith) are fine; none of them is the bottleneck. The bottleneck is not having a labeled set, and the first fifty examples can be hand-labeled in an afternoon.

Learn: the harness, MCP and sandboxinglink

The file system as state and the think-act-observe loop. For an agent doing real multi-step work, the durable architecture is exactly that: think, act, observe, repeat, with files (or a structured store) as the source of truth and every action logged and replayable. Claude Code, Cursor, Devin, Aider, OpenHands and goose all converged on it. The model is stateless, so the harness has to be stateful.

That leads to a deeper idea: in any serious agent, the harness does more work than the model. The model picks the next action; the harness validates it, runs it in a sandbox, captures the output, decides what to feed back, when to stop, when to checkpoint and when to spawn a subagent. Swap the model for a similar one and, with a good harness, everything keeps working; put in a worse harness and even the best model randomly forgets what it was doing.

The harness around the model, with every job it does
The model is a component inside the harness.

MCP, conceptually. Knowing how to call its servers is not enough: understand the clean separation between agent capabilities, tools and resources, with extensible auth and transport underneath. Once you do, every other integration framework looks like a worse version. The Linux Foundation now stewards it and the major providers back it; calling it "the USB-C of AI" no longer sounds ironic.

Sandboxing as a primitive. Every production coding agent runs in a sandbox, and every browser agent has been hit by indirect prompt injection. The basics: process isolation, network egress controls, secret scoping and permission boundaries between agent and tools. Teams that bolt this on after a customer security review lose the deal; teams that build it in from week one pass enterprise procurement without sweating.

What to build withlink

These are the author's picks as of April 2026, and his advice is to pick boringly:

LayerAuthor's pick
OrchestrationLangGraph by default (according to him, roughly a third of large companies running agents use it; it is verbose, but that verbosity is what you need to control). Mastra if you live in TypeScript. Pydantic AI for greenfield work with type safety (it hit v1.0 in late 2025). The Anthropic and OpenAI agent SDKs inside LangGraph nodes, not as the top-level orchestrator.
ProtocolMCP, full stop: you can almost always find a server before you need to build one.
MemoryBy autonomy level: Mem0 for chat personalization, Zep for production conversations that track entities, Letta for agents that stay coherent over days or weeks. The mistake is reaching for a memory framework before you have a memory problem.
Observability and evalsLangfuse as the open-source default; LangSmith if you are already a LangChain shop; Braintrust for rigorous comparisons; OpenLLMetry/Traceloop for vendor-neutral OpenTelemetry. You need tracing (what did the agent do) and evals (is it better than yesterday).
Sandboxed runtimeE2B for code execution, Browserbase (with Stagehand) for the browser, Anthropic Computer Use for real desktop control and Modal for short bursts. Never unsandboxed code.
ModelsClaude Opus 4.7 and Sonnet 4.6 for reliable tool use (Sonnet, the cost-performance sweet spot); GPT-5.4 and 5.5 for terminal reasoning; Gemini 2.5 and 3 for long-context or multimodal jobs; DeepSeek-V3.2 or Qwen 3.6 when cost matters most.
The author's picks for building agents in April 2026
The author's picks, April 2026. They will shift, but slowly.

And one rule for models: treat them as swappable. If your agent only works with one, that is a smell, not a moat. Let your evals decide, and re-evaluate every quarter, not every week.

What to skiplink

You will be told to learn all of it. Skipping costs little and saves a lot of time. The author's list:

  • AutoGen and AG2 for production: moved to community maintenance and releases stalled. Fine for exploring, not for anchoring a product.
  • CrewAI for new production builds: it is everywhere because it demos easily; use it for prototypes if you want.
  • Semantic Kernel, unless you are locked into the Microsoft stack. DSPy, unless you optimize prompt programs at scale.
  • Code-writing agents as your base architecture: interesting research, not a production default yet.
  • Autonomous-agent pitches: the AutoGPT and BabyAGI lineage is dead in product form. The industry settled on agentic engineering: supervised, bounded and evaluated.
  • Agent app stores and horizontal "build any agent" platforms as a customer (with the exceptions of Salesforce Agentforce and ServiceNow Now Assist, which live inside workflow systems you already use).
  • Chasing SWE-bench or OSWorld: Berkeley researchers documented through 2025 that nearly every public benchmark can be gamed without solving the underlying task.
  • Naive parallel multi-agent setups: if you cannot draw the orchestrator with its read/write boundaries on a napkin, do not ship it.
  • Per-seat pricing for new agent products: the market moved to outcome and usage-based pricing.
  • The next framework on Hacker News: wait six months.
Framework cards crossed out with the author's caveat
Not that they are bad: the author just would not anchor a new product on them.

How to actually movelink

If you want to adopt agents, not just keep up with them, this sequence is boring and it works:

  1. Pick one outcome that already matters. No moonshots and no "agent platform" projects: deflecting support tickets, first-pass legal review, qualifying inbound leads, monthly reports. That number is your eval target from day one, and it constrains everything else: framework, model, memory or subagents follow from it.
  2. Tracing and evals before you ship anything. Langfuse or LangSmith, and fifty hand-labeled examples. Building it later costs, according to the author, roughly ten times more.
  3. A single agent. LangGraph or Pydantic AI, a model like Sonnet or GPT, three to seven well-designed tools and files or a database as state. To a small audience, watching the traces.
  4. Treat it as a product, not a project. Its failures are your roadmap; every change goes through evals.
  5. Add scope only when you have earned it. Subagents when context is the bottleneck; memory when one window cannot hold it; computer use when the APIs are not there.
  6. Boring infrastructure: MCP, E2B or Browserbase, the data store you already run and your usual stack.
  7. Watch unit economics from day one. The author's example: a $0.50-per-run proof of concept becomes $50K a month at moderate volume.
  8. Re-evaluate models quarterly, not weekly.
The steps to adopt agents, with the current one highlighted
Eight steps. The first one constrains all the others.

Reading the tidelink

It is signal if…

A respected team publishes a postmortem with numbers. It is a primitive, not a wrapper. It interoperates with what you already run. The pitch describes the failure it solves, not the capability it enables. It has been around long enough to have a "what didn't work" post.

It is noise if…

There are demo videos with no production cases after thirty days. Benchmark leaps look too clean. It promises "autonomous", "agent OS" or "build any agent" without qualification. Its docs assume you will throw away your tracing and config. GitHub stars rise without commits or releases.

Tells that something is signal or noise
Concrete tells for reading the tide.

And a weekly habit: thirty minutes on Friday to read three things (Anthropic's engineering blog, Simon Willison's notes and Latent Space), one or two postmortems if any landed, and nothing else.

What to watchlink

Six things whose "is this signal?" question has not resolved yet:

  • Replit Agent 4's parallel forking model, running agents in parallel without tripping over shared state.
  • Outcome-based pricing, which Sierra and Harvey validate in their verticals.
  • Skills as a packaging layer (AGENTS.md and skills directories): will they standardize the way MCP did?
  • Claude Code's April 2026 quality regression and its postmortem: users catching it before internal monitoring shows how immature production evals still are.
  • Voice as the default support surface: at Sierra it overtook text in late 2025.
  • Open models closing the gap, like DeepSeek and Qwen.

For each one, the same question applies: what would you need to see in six months to believe it.

The unconventional betlink

Every framework you do not adopt is a migration you do not owe, and every benchmark you do not chase is a quarter of focus you keep. The companies winning this cycle (Sierra, Harvey, Cursor) picked narrow targets, built boring discipline and let the noise pass them by.

The conventional path was to pick a stack, master it for years and climb a ladder. But the stack changes every quarter, and the companies, their frameworks and their protocols are months or a few years old. There is no ladder, because the building keeps changing floors. What is left is the oldest method: make a thing, put it on the internet and let the work introduce you. The credential is the artifact.

The skill you need is not "agents": it is knowing which work compounds. Context engineering, tool design, the orchestrator pattern, eval discipline and the harness mindset compound; knowing the API of the framework that launched on Tuesday does not.

How to read this articlelink

  • It is an opinion guide. The tool and model picks are the author's, as of April 2026.
  • Unsourced figures are his: the 90% mortality of frameworks-turned-platforms, LangGraph's "roughly a third" or "ten times the cost" are estimates, not measurements.
  • Third-party figures belong to third parties: the 47% Claude Code regression is reported by the author; the 40% comes from an unnamed team; Spotify's 25% from its engineering blog.
  • "Skip" does not mean "bad": the author himself keeps AutoGen for exploration and CrewAI for prototypes.

In shortlink

My takeaway: you do not need to learn everything, only what compounds, and skip the rest. Pick an outcome, set up tracing and evals before you ship, use MCP, sandbox your runtime, start with a single agent, re-evaluate models quarterly and read three things every Friday.

In one sentence

The era rewards people who make the thing more than people who can describe it: build, and put it on the internet.

Which framework are you going to skip this year?

Sourceslink

Continue reading

Last posts -->

Have you seen these projects?

Gymnasia

Gymnasia Gymnasia
Expo
React Native
TypeScript
OpenAI
Anthropic

Fitness app with two agents that run entirely on the device, with no backend, so the user's data never leaves the phone. A BYOK conversational coach with local tools and a remote system prompt with offline fallback, plus a food estimator that pulls macronutrients out of a photo of the plate, with barcode scanning against OpenFoodFacts.

LangGraph Deep Researcher

LangGraph Deep Researcher LangGraph Deep Researcher
Python
LangGraph
FastAPI
React
TypeScript
Docker

Multi-agent research system built with LangGraph. A supervisor breaks your question down into topics and launches search sub-agents in parallel; each one compresses its findings before handing them to a writer agent that produces the final sourced markdown report. Live streaming over WebSockets, a configurable model per role and bring-your-own API keys that are never persisted server-side.

Tau

Tau Tau
Python
LangChain

Multi-agent tutoring system for secondary school students, with one agent per subject and course material written and validated by a team of teachers. It was used with real students at a private school in Spain and at a secondary school in Colombia.

View all projects -->
>_ Available for projects

Do you have an AI project?

Let's talk.

maximofn@gmail.com

Machine Learning and AI specialist. I develop solutions with generative AI, intelligent agents and custom models.

Do you want to watch any talk?

Last talks -->

Do you want to improve with these tips?

Last tips -->

Use this locally

Hugging Face spaces allow us to run models with very simple demos, but what if the demo breaks? Or if the user deletes it? That's why I've created docker containers with some interesting spaces, to be able to use them locally, whatever happens. In fact, if you click on any project view button, it may take you to a space that doesn't work.

Flow edit

Flow edit Flow edit

FLUX.1-RealismLora

FLUX.1-RealismLora FLUX.1-RealismLora
View all containers -->
>_ Available for projects

Do you have an AI project?

Let's talk.

maximofn@gmail.com

Machine Learning and AI specialist. I develop solutions with generative AI, intelligent agents and custom models.

Do you want to train your model with these datasets?

short-jokes-dataset

HuggingFace

Dataset with jokes in English

Use: Fine-tuning text generation models for humor

231K rows 2 columns 45 MB
View on HuggingFace →

opus100

HuggingFace

Dataset with translations from English to Spanish

Use: Training English-Spanish translation models

1M rows 2 columns 210 MB
View on HuggingFace →

netflix_titles

HuggingFace

Dataset with Netflix movies and series

Use: Netflix catalog analysis and recommendation systems

8.8K rows 12 columns 3.5 MB
View on HuggingFace →
View more datasets -->