How to Build Agents in 2026: Low-level Runtimes vs Orchestration Frameworks

When I built Skillenai's Talent Insights chat experience — the one that helps you search jobs, read your resume, and reason over the labor-market graph — I skipped the agent framework entirely. No LangGraph. No LangChain. No FastAPI. No MCP server.

I knew from the day Claude Managed Agents launched on April 8, 2026 that it would be the tool I used to build Skillenai's chat experience. The entire "framework" is four primitives: a file system, a bash shell, a code sandbox, and our own API. This is a low-level runtime, not an orchestration framework. And it's the best way to build agents in 2026.

It is dramatically more capable than the version I would have built in 2025, when I would have wired up an orchestration graph in LangGraph by reflex. And when I went to check whether this was just my taste or an actual shift, our own data said the field is already moving this way — fast.

The 2025 stack was answering three questions with one answer

If you built an AI feature in 2025, you probably reached for some combination of an orchestration framework (LangChain / LangGraph), a vector database for retrieval, a web framework (FastAPI) to glue tools together, and MCP to expose those tools externally. That stack works. But it quietly conflates three completely different problems into one architecture:

1. How do I let an assistant I don't own (ChatGPT, Gemini) touch my product?
2. How do I let coding agents (Claude Code) drive my product?
3. How do I build my own chat experience inside my own app?

These are not the same question, and they do not have the same answer. Once you separate them, most of the orchestration machinery turns out to be solving a problem you don't have.

Three surfaces, three stacks

Here's the model I now build against:

You want to reach…	The right play	Why
Users inside someone else's chat (ChatGPT, Gemini)	Build an MCP server	You don't own the loop, so you expose a clean, declarative integration the host can call. MCP is an integration play.
Claude Code users	Ship an API + skills	A documented API plus a thin skill layer lets the world's coding agents drive your product with zero bespoke glue. (Skillenai ships exactly this: skillenai-api-skill.)
Your own in-app chat	file + bash + sandbox + your API	You own the loop, so give the agent a computer. Maximum flexibility, maximum capability. This is Managed Agents.

MCP is not the loser here. MCP is the right tool for surface #1 — and it's a genuinely good one. The thing that's aging is the assumption that an orchestration framework is the right tool for surface #3. For a chat you own, it isn't.

Why a computer beats a graph

When you build your own chat on an orchestration framework, every new capability is a new node: define the tool, write the schema, wire it into the graph, handle the state transition. You are hand-authoring a flowchart of everything the agent is allowed to do, and the agent can only ever do what's on the flowchart.

When you give the agent file-edit + bash + a sandbox + your API, capability becomes open-ended:

• Need it to cross-reference two resumes? It writes a Python script in the sandbox and runs it. No new node.
• Need a new data cut from our backend? It curls our API and pipes the JSON through jq. No new tool definition.
• Need to remember something across turns? It writes a file.
• Need a chart? It generates one with matplotlib and hands back the PNG.

The agent isn't choosing from a menu I pre-wrote. It's composing primitives the way an engineer would — because under the hood, that's exactly what a coding agent is good at. The job is no longer "anticipate and wire every workflow." It's "give the agent a good API and a clean environment, then get out of the way." Anything I can do from a terminal, the agent can do on a user's behalf.

That's not a small ergonomic win. It's the difference between a product whose ceiling is the flowchart I had time to draw and one whose ceiling is "whatever can be scripted."

Is this a real trend, or just my taste?

I'm biased — I build on Claude, I like this pattern, and I just built a product around it. So I went to the data to check where the industry is trending. Skillenai continuously ingests job postings, technical blog posts, and tech news; I measured how often each corpus mentions the orchestration-framework camp (LangChain, LangGraph, RAG/vector-DB plumbing) versus the low-level runtime camp (code execution, sandboxes, bash/file-edit tools, agent SDKs), with MCP tracked separately as the integration layer.

The news corpus is the leading indicator — it's where the frontier conversation happens first. Here's what "how to build an agent" looks like there:

Among news articles that mention either camp, the low-level runtime share climbed from roughly one-third at the start of 2026 to 71% by May. And to be clear about the measurement: this is brand-independent. It excludes the term "Claude Code" entirely and excludes the noisy phrase "computer use." It's counting generic architecture language — code execution, sandbox, bash tool, file-edit, agent SDK — and the runtime camp still wins going away.

This timing is no coincidence — Claude Managed Agents was released on April 8, 2026. That release re-shaped the conversation away from orchestration frameworks and towards low-level runtimes.

Break it out by raw mention rate and you see the three surfaces move independently:

- Orchestration frameworks: mention rate roughly halved from March to May 2026.
- Low-level runtime: up about 60% over the same window.
- MCP: flat-to-up. It is not the casualty. It's the integration layer, and it's holding.

That divergence is the part I trust most. If this were just an artifact of our crawler ingesting more AI content in 2026, all three lines would rise together. Instead frameworks fall while runtime rises in the same denominator — that's a real shift in what people are writing about, not a measurement quirk.

The catch: hiring is two surfaces behind

Before you rewrite your stack on a Tuesday, here's the honest caveat. Mentions in news and blogs are discourse, not deployments. The closest thing we have to a measure of what's actually running in production is what employers ask for in job postings — and there, the 2025 stack still rules:

| Surface | Orchestration /10k | Low-level runtime /10k | MCP /10k |
| --- | --- | --- | --- |
| News (frontier discourse) | 206 | 274 | 217 |
| Blog (tutorials / how-tos) | 297 | 168 | 264 |
| Jobs (what employers require) | 310 | 26 | 74 |

Read top to bottom and you see a clean cascade. News has already flipped to favor the runtime camp. Blog tutorials are mid-transition — still framework-leaning, because how-to content always lags the conversation it documents. And job requirements still favor the 2025 framework stack by about 12 to 1. The discourse has moved roughly two surfaces ahead of the postings.

So if you're hiring: the résumés screening "LangChain/LangGraph" are matching a market that's already turning. And if you're a builder: the frontier has moved, but the job market hasn't priced it in yet. That gap is the opportunity.

What I'd tell you to do

• Building on someone else's assistant? Ship an MCP server. It's the right tool and it's not going anywhere.
• Want coding agents to use your product? Publish a clean API and a thin skill layer. "Claude Code" is now the single most-mentioned term across every corpus we track — that audience is real and large.
• Building your own chat? Give the agent a computer — file, bash, sandbox — plus your own API, and delete the orchestration graph. You'll write less code and ship a product with a much higher ceiling.

The 2025 instinct to reach for a framework wasn't wrong for its moment. It's just that "give the model a terminal and a good API" turned out to be more flexible than any flowchart I could draw — and the data says I'm not the only one who's noticed.

---

Full methodology, monthly data, and reproducible charts: skillenai-notebooks/three-surfaces-agent-stack. Measured across 220K job postings, 445K blog posts, and 141K news articles in the Skillenai corpus. Mention rates are match_phrase prevalence on document text; time series use monthly publication-date shares to cancel crawl-volume bias. These count what's written and hired about — not production deployments — so treat the trend as direction, not magnitude.