The AI talent market feels lopsided right now. Companies have uncapped budgets and still can't find enough people who can actually deliver. Training programs are everywhere. Yet a real gap persists between what most courses teach and what teams are hiring for.

The difference often comes down to artifacts. Not certificates. Not video completions. What have you actually built that runs reliably when real users or real workflows depend on it?

That is the filter employers use. And it is exactly where most agentic projects quietly die.

The Three Failure Modes That Kill Agentic Systems

Even capable builders run into the same problems once they move past simple demos.

Context degradation sits at the top. Long-running agents or multi-step tool chains slowly lose the thread. The agent starts working with incomplete or outdated information. Tools receive only fragments of the original intent. Performance drifts. Outputs get weird. Eventually the whole thing becomes unreliable without anyone noticing exactly when it broke.

Tool selection errors come next. The agent picks the wrong tool for the job or uses the right tool in ways it was never designed to handle. One bad choice cascades. The system produces plausible but wrong results, or it fails in ways that are hard to trace back to the original mistake.

Cascading errors and silent failures finish the job. A small mismatch in one step creates bigger problems downstream. Sometimes the failure is loud. More often it is quiet. The agent keeps running, users see degraded output, and nobody catches it until trust is already damaged or money is lost.

These are not edge cases. They are the default experience for most teams trying to ship agentic systems today.

How Trustabl Agent Analyzer Changes the Equation

Trustabl.ai built Agent Analyzer specifically to attack these failure modes at the source.

It starts with context. Agent Analyzer does not just feed the main agent a prompt. It supplies rich, structured context to both the agent and the tools it calls. Tools operate with the same depth of understanding the agent has. Alignment lasts longer. Drift happens less. The entire system stays coherent across complex or extended interactions.

Next comes tool discipline. Agent Analyzer includes explicit fields that define what each tool is for and, just as importantly, what it should never be used for. This guidance sits right where the agent makes decisions. Selection errors drop because the boundaries are clear and machine-readable. The agent does not have to guess or improvise its way into misuse.

Then there is early detection. Agent Analyzer brings built-in observability and supports pre-testing workflows, including environments like OpenShell. Problems surface while they are still small and cheap to fix. You catch the mismatch before it cascades. You see the silent degradation before users do. The system stops rewarding hidden failures.

The result is agents that move from promising demo to production-ready with far less manual firefighting.

Almost Completely Automatic, Built for How You Already Work

The real advantage is how little extra work it creates. Agent Analyzer integrates with the development tools and workflows you already use. It is almost completely automatic. You do not have to pause your process to become a full-time reliability specialist. You keep building. The scanner layers in the robustness checks, context enrichment, and guardrails.

This matters for upskilling. The agentic job market rewards people who can demonstrate judgment in architecture, evaluation, testing, and hardening. Not just prompting skill. Agent Analyzer lets you practice those exact muscles while producing real artifacts. You are not watching another course. You are shipping agents that survive contact with reality.

That is the middle layer of capability most training still misses. High-level overviews on one side. Deep theory on the other. Practical production hardening sits in between. Agent Analyzer gives you a concrete way to build and show that layer.

The Path Forward

Nate and others have pointed out the split in the market. Infinite demand exists alongside real friction for individuals trying to prove they belong on the right side of it. The people who win are the ones who can point to working systems they built and maintained.

Agent Analyzer removes the most common reasons those systems fail. It gives you richer context, clearer tool boundaries, and early visibility into problems. It does so while fitting into how you already develop.

If you want to build production-ready agents instead of another set of demo videos, this is the lever. It turns the painful parts of agentic work into something closer to automatic.

The teams that are actually hiring right now need people who ship reliable automation. Agent Analyzer helps you become one of them faster.

Start scanning and strengthening your agents at trustabl.ai.

A new paper from Queen’s University researchers didn’t just theorize about flaky AI agents. They measured it.

They analyzed 856 tools across 103 real MCP servers (both official ones from big names and community-built ones). Using a structured rubric and an FM-based scanner, they found that 97.1% of tool descriptions contain at least one “smell.”

More than half (56%) fail to clearly state the tool’s purpose. Nearly 90% miss usage guidelines or limitations. Most leave parameters opaque.

These aren’t minor documentation nits. They are the exact reasons agents pick the wrong tool, pass bad arguments, lose context over long chains, or silently degrade until something breaks.

The researchers called these issues “smells.” We see them every day as the root causes of production pain.

What the Paper Actually Found (and Why the Stats Matter)

The team built a clear scoring rubric around six components that good tool descriptions should have: Purpose, Guidelines, Limitations, Parameter Explanation, Length & Completeness, and Examples.

They then ran a multi-model “LLM-as-Jury” scanner across hundreds of real descriptions. The results were stark:

• Only 2.9% of descriptions were clean across the key components.
• Problems appeared equally in official and community servers — this is systemic, not a “some indie devs are sloppy” issue.
• When they augmented the descriptions (adding the missing clarity), agents on the MCP-Universe benchmark saw a median 5.85 percentage point lift in task success rate and a 15.12% improvement in partial goal completion.

But here’s the honest part the paper also surfaces: richer descriptions increased execution steps by a median of 67.46%. In 16.67% of cases, performance actually regressed. More information helps — until it bloats context or introduces new ambiguity.

This isn’t hand-wavy. It’s measured, statistical validation that insufficient tool metadata is a widespread, measurable drag on agent reliability.

The “Smells” Map Directly to the Failures You Feel

If you’ve shipped agentic systems, these will sound painfully familiar:

• Unclear Purpose + Missing Usage Guidelines → Tool selection errors. The agent doesn’t know when (or when not) to reach for a tool, so it guesses or picks the wrong one.
• Unstated Limitations + Opaque Parameters → Context degradation and bad arguments. The agent (and the tools themselves) operate with incomplete pictures, leading to drift over multi-step workflows.
• Underspecified or Incomplete descriptions → Cascading and silent failures. Small misunderstandings compound. Sometimes the agent keeps running while producing quietly wrong results until a user or downstream system notices.

The paper shows these aren’t rare edge cases. They are the default state of most MCP tool descriptions today.

That academic rigor is useful because it removes the “maybe it’s just our setup” doubt. The problem is real, it’s everywhere in the wild, and it directly undermines production reliability.

This Is Exactly Why We Built Trustabl Agent Analyzer

At Trustabl, we’ve been watching the same pattern: developers wire up promising agents, everything looks good in demos, then real workloads expose the gaps. The descriptions that came with the tools simply weren’t built for the demands of production agentic systems.

Agent Analyzer was designed to close that gap automatically.

Instead of leaving agents to work with thin, ambiguous metadata, Agent Analyzer enriches the picture with rich context that reaches both the agent and the tools themselves. It adds explicit guidance on what a tool is for,  and, just as importantly, what it is not for. It layers in observability and supports early pre-testing (including environments like OpenShell) so issues surface while they’re still cheap to fix.

The result? Agents that move from “mostly works in testing” to production-ready with far less manual debugging.

We didn’t invent the need for better descriptions. The Queen’s University team just proved how widespread and costly the current state is. Agent Analyzer turns that insight into something you can apply to your own tools and workflows, almost completely automatically, and without ripping out your existing development process.

The Practical Takeaway

The paper also shows something important for builders: simply making descriptions longer isn’t always the win. Smart, targeted enrichment often delivers most of the benefit with less overhead. That aligns with how Agent Analyzer works,  focused richness rather than blanket verbosity.

If you’re trying to ship reliable agentic systems (or upskill into roles that actually require shipping them), the bottleneck isn’t usually the model. It’s the quality of the instructions and context those models receive about the tools they can use.

The research confirms the pain is real and systemic. Agent Analyzer exists to make fixing it practical and automatic.

Head over to trustabl.ai and see what Agent Analyzer can do with the tools you’re already using. Turn descriptions that currently create friction into ones that actually support smooth, reliable production behavior.

The data says the problem is everywhere. Now you have a straightforward way to address it.

AI agents are getting more powerful by the month. At the same time, many teams are watching their token bills climb and their context windows fill up faster than expected. The problem is rarely the model itself. A significant contributor to token waste is how tools are described and how agents decide which ones to call 

Trustabl’s Agent Analyzer system tackles this at the root. Instead of treating tools as simple function definitions with a paragraph of text, Agent Analyzer adds structured, production-grade metadata that helps agents make better decisions from the start.

The Real Cost of Poor Tool Metadata

When a tool only has a basic name and description, the agent has to guess. It tries the wrong tool. It passes parameters in the wrong format. It hits an error and then spends several turns reasoning about what went wrong and what to try next.

Each of those extra steps costs tokens. Multiply that across thousands of agent runs and the waste adds up quickly. Many organizations are now seeing token usage dominated by failed paths and retry loops rather than successful work.

Agent Analyzer changes this by giving agents the information they actually need to succeed on the first or second attempt.

How Agent Analyzer Cuts Token Waste

Agent Analyzer works by enriching every tool with fields that directly influence agent behavior. Here are the main ways it reduces token consumption:

Area Improved	What Usually Happens Without It	How Agent Analyzer Helps	Token Savings Impact
Tool Selection	Agent experiments with several tools before finding the right one	Clear when_to_use and when_not_to_use rules	Very High
Error Recovery	Long chains of reasoning after every failure	Structured error catalog with resolution steps	High
Retry Logic	Repeated calls on non-idempotent operations	Explicit idempotency and recommended retry policies	High
Prompt Length	Verbose instructions repeated in every system prompt	Compact, ready-to-use prompt snippets and examples	Medium to High
First-Try Success Rate	High percentage of failed trajectories	Overall hardening lifts success rates significantly	Very High

The biggest wins usually come from fewer wrong tool calls and much shorter error loops. When an agent knows exactly when a tool should and should not be used, it stops wasting context on exploration.

Better Decisions Lead to Shorter Conversations

One of the most underappreciated sources of token usage is the length of the conversation itself. A successful agent run might take 4-6 steps. A struggling run can easily stretch to 15 or 20 steps as the model tries different approaches, interprets vague errors, and backtracks.

Agent Analyzer shortens those trajectories. With strong validation rules, clear side effect declarations, and practical examples baked in, agents reach correct outcomes faster. The model spends fewer tokens second-guessing itself.

In practice, teams using well-hardened tools often see meaningful reductions in average tokens per successful task. The improvement compounds because cleaner runs also mean less debugging and fewer follow-up corrections later.

It Also Enables Smarter Routing

Rich metadata does more than just improve single-tool calls. It opens the door to better system-level decisions. With clear purpose statements, applicability rules, and risk levels attached to every tool, you can build routing layers that only surface the most relevant tools to the main agent.

This keeps the primary context window smaller while still giving the agent access to everything it might need. Many teams are starting to combine Agent Analyzer metadata with semantic retrieval so the agent only sees a handful of high-probability tools instead of dozens.

The Bottom Line

Token usage in agentic systems is not just a cost problem. It is also a reliability and latency problem. Every extra failed step increases both spend and the chance that the agent will eventually give up or hallucinate a workaround.

Agent Analyzer attacks the issue at the tool level, where the leverage is highest. By giving agents precise, structured information about when to use a tool, how to call it correctly, and what to do when something goes wrong, it raises the success rate on the first attempt.

The result is shorter conversations, fewer wasted tokens, fewer hallucinations, and agents that feel more reliable in production.

If you are building or scaling agent workflows, the quality of your tool metadata is quickly becoming a competitive differentiator. The teams that treat tool hardening as a first-class part of their stack will spend less on tokens and ship more capable agents.

Curious how Agent Analyzer would apply to the tools you are already running? Feel free to reach out. I am happy to walk through what the hardening process looks like with real examples.