Nobody did a big press release. There was no GPT launch event. No founder went on stage and declared the problem solved.

But over the last six months, agent tooling crossed the line from demo garbage to production infrastructure. We are no longer arguing if agents work. We are now arguing about how to run them reliably.

All the recent work is not flashy demos. It is plumbing. And that is the sign that something is actually going to get used.

The quiet shift

For three years every agent announcement was the same. Someone would record a 90 second clip of an agent booking a flight or ordering a pizza. It would go viral. Then everyone would find out it failed 8 out of 10 times and cost $12 per run.

That era ended.

Nobody is making those demos anymore. Instead people are building the boring, unglamorous layers required to run agents every day. This article walks through every major component of the new agent stack that landed in the last two months, what works, what is broken, and what you will be building with next year.

We finally agreed how agents talk to tools

For two years every agent framework invented its own tool calling format. Everyone hated it. Nobody said it out loud.

That ended. MCP won. Not by standard body vote, not by Google announcement. Just by every single project quietly adopting it.

webMCP is the user facing end of this. Sylwia Lask's demo showed exactly why this works: it is progressive enhancement, exactly like ARIA roles for accessibility. You do not rewrite your website. You add annotations. Agents stop scraping and guessing. Token usage drops 70%.

The best part of webMCP is not what it does for agents. It is what it does for humans. The same structured action annotations that let an agent submit a support ticket will let a screen reader user submit that ticket too. We accidentally built better accessibility tools while trying to build robot interfaces.

There are problems. Nobody has solved authorization yet. Right now if you expose a tool, every agent can call it. We built the highways before we built traffic lights. That will get someone fired. Literally. But that is a much better problem to have than every agent running Selenium against your login form.

CLI tools are now built for two audiences

Hugging Face dropped the most important agent result nobody talked about. They rebuilt their hf CLI to detect when an agent is running it, and change output format accordingly.

Humans get colored tables, truncated output, progress bars. Agents get full TSV, no ANSI codes, no truncation, exact ISO timestamps, and explicit next command hints.

The results are brutal. On multi step tasks, agents using the hf CLI use 6x fewer tokens and succeed 10 percentage points more often than agents hand rolling curl or the Python SDK.

This is not an optimization. This is a permanent shift in how we build command line tools. Every CLI you build from now on will have an agent mode. This is the new responsive design. You will not get a choice.

The agent internet layer exists now

Agents are terrible at the internet. They can write perfect sorting algorithms but they cannot read a tweet. Every platform has captchas, IP bans, broken APIs, login walls.

Agent Reach solved this. It is not a framework. It is a scaffolding. You paste one line into your agent, and ten minutes later it can read Twitter, Reddit, YouTube, Bilibili, Xiaohongshu, every single walled garden, all for free, no API keys.

It works by not inventing anything. It just installs and configures all the existing open source scrapers correctly. That is it. That is the entire product. And it is the most useful agent tool released this year.

Nobody will build a general purpose agent that works on the internet until this layer exists. Now it does.

Memory stopped being a marketing buzzword

For three years every agent memory product lied about their recall numbers. Everyone published benchmarks on their own test sets. Nobody could reproduce anything.

MemPalace showed up and published 96.6% R@5 on LongMemEval. No LLM required. No cloud API calls. Everything runs locally.

They did not do anything fancy. They just did it correctly. No summarization. No paraphrasing. Store verbatim. Good embeddings. Simple hybrid search. That beats every fancy commercial memory product by 15+ points.

This is the pattern over and over again. All the winning agent tools are boring. They do the obvious thing correctly. They do not add magic. They remove broken magic.

Document parsing is solved

If you have ever built a RAG or agent system you know the worst part is parsing documents. Everyone spends 80% of their time cleaning garbage OCR output.

PaddleOCR 3.5 fixed this. 96.3% accuracy on OmniDocBench. Handles tables, formulas, seals, hand writing, 111 languages. Outputs clean markdown directly. Runs locally. Beats every closed source commercial parser.

This was the last major bottleneck for production agents. It is gone now.

Real agents do not look like chat boxes

Everyone is complaining that every SaaS product added an agent chat box that nobody asked for. They are right to complain.

Almost none of those are actual agents. They are a single LLM call wrapped in a loading spinner.

An actual agent owns a loop. It observes state. It plans. It acts. It verifies the result. It repeats until done.

The best example of this right now is daily_stock_analysis. It does not chat. It wakes up once per day. It pulls data. It runs analysis. It writes a report. It sends it to your slack. It goes back to sleep. Nobody types at it. It just does its job.

That is what 99% of useful production agents will look like. They will not be your assistant. They will be your night shift.

Production frameworks finally arrived

Microsoft shipped Agent Framework. This is not another demo framework. This is for teams that are actually deploying agents to production.

It has checkpointing. Restartability. OpenTelemetry. Human in the loop. Durable workflows. Runs on Python and .NET. Migrates cleanly from Semantic Kernel and AutoGen.

Most importantly it admits that you will change your LLM provider three times. All the good frameworks now assume you will swap models. The ones that lock you to one provider are already dead.

The unsolved problems

None of this means we are done. We still have huge, unsolved, mostly unspoken problems.

Authorization across tools is still completely broken. Nobody knows how to give an agent least privilege access. Right now we either give it root or nothing.

Agent identity does not exist. There is no way for a website to know which agent is calling it, or what permissions it should have.

Observability is terrible. You still cannot reliably answer "why did the agent do that?".

Cost is still out of control. A 10 step agent loop still costs more than paying an intern to do the same job. This will get fixed, but not fast enough for most people.

What comes next

We are not heading for a world with one super agent that does everything. We are heading for a world with a thousand tiny, boring, specialized agents. One that fills out your expense reports. One that monitors your servers. One that updates your dependencies. One that reads your support tickets.

None of them will talk to you. None of them will have a personality. They will just do their job quietly in the background.

That is the actual agent future. It is not exciting. It is not scary. It is just boring infrastructure.

And that is exactly when it starts to matter.