The agent ecosystem is obsessed with tools. MCP servers, tool calling, function calling—every framework announcement centers on how many tools you can connect. But tools are the wrong abstraction for where we're headed. We should be talking about skills.
The choice of word matters, because it reflects the difference between building copilots and building agents that can actually work on their own.
Why were tools right for copilots?
Tools made sense in 2024. A human sat in the loop, providing judgment. The agent called get_weather(city) or send_email(to, subject, body), and the human decided what to do with the result.
This works when:
- Tasks are single-step or short sequences
- A human validates each decision
- Context doesn't compound
Most "agents" today are still copilots. They suggest and draft, and a person approves and edits, so the human still provides the judgment. According to Stack Overflow's 2025 Developer Survey, 84% of developers now use AI tools, with 51% using them daily—the majority are using them as assistants, not autonomous agents.
But the ceiling is visible. In coding, we went from "AI autocompletes my line" to "AI writes most of the code while I review." Microsoft CEO Satya Nadella recently revealed that 20-30% of Microsoft's code is now AI-generated. At the extreme end, Y Combinator reported that 25% of their Winter 2025 founders had 95% of their code generated by AI.
The ratio keeps shifting, and the human in the loop is becoming human-on-the-loop, then human-out-of-the-loop.
Once the human steps back, the tool model starts to break down.
Human decides what's right
Skills know what's right
Why does the tool mental model break at autonomy?
Tools are atomic—stateless functions that execute and return. search_web(query) doesn't know why you're searching or what counts as a good result. send_slack_message(channel, text) doesn't know if now is the right time to send it.
This is fine when a human is orchestrating, because the human holds the context, the judgment and the domain knowledge.
When an agent orchestrates autonomously, it needs that judgment embedded. As IBM's research team puts it, a true AI agent is "an intelligent entity with reasoning and planning capabilities that can autonomously take action"—but those reasoning and planning capabilities are exactly what tools don't provide.
A tool can't tell you:
- When to use it vs. when to skip it
- What success looks like
- How to handle the edge case you didn't anticipate
- What to do when it fails
This is where the tool abstraction hits its ceiling.
What actually is a skill?
A skill is a packaged capability—not just a function, but the expertise to use it well.
Think about what it actually means to learn a craft. You can hand someone a hammer, a saw, and a tape measure—they now have tools. But watch them try to build a cabinet. They'll drive nails at the wrong angle. They'll cut boards without accounting for the blade width. They'll measure once, cut twice, and wonder why nothing fits.
Now compare that to someone who's learned carpentry. They have the same hammer, but they also know which wood to use for which purpose, how humidity affects joints, when to use screws instead of nails, and how to recover when a cut goes wrong. Both people have identical tools, yet their ability to build a cabinet is completely different.
That is the gap between tools and skills. A tool performs an action, while a skill includes the judgment to use that action well.
Concrete example: "Email Outreach" as a skill
A tool approach gives you:
send_email(to, subject, body)check_inbox()get_contact_info(name)
An agent with these tools can technically send emails. But it doesn't know:
- How many follow-ups are appropriate before you're spamming
- That Tuesday morning converts better than Friday afternoon
- To check if this person was contacted by a colleague last week
- What "success" means—open rate? reply? meeting booked?
- How to adjust tone for a CEO vs. a developer
A skill packages all of this:
- The tools, yes
- Instructions: "Follow up twice, spaced 3-4 days apart. Stop if they reply or unsubscribe."
- Context: "Reference their recent funding round if applicable. Match formality to their LinkedIn tone."
- Data: Integration with CRM to check contact history
- Evaluation: "Success = reply or meeting. Failure = bounce or unsubscribe."
- Recovery: "If email bounces, try to find alternate contact via LinkedIn."
The skill does more than execute an action, because it carries the knowledge of how the job should be done.
How do skills and tools fit together?
Tools do not disappear in this picture. They become components inside skills:
In short, agents call tools, but they need skills to know how and when to use them.
Why isn't MCP enough?
MCP moved the industry forward. It standardized how tools connect to agents—tools, prompts, and resources in one protocol. But MCP is infrastructure, not the full stack.
What's missing:
No evaluation. How do you know a skill works? MCP doesn't define testing, quality metrics, or reliability signals. You're trusting the tool author blindly. This matters: more developers now actively distrust AI tool accuracy (46%) than trust it (33%).
No composability. Real tasks require skills to chain—research feeds into outreach feeds into CRM updates. MCP doesn't specify how capabilities compose or hand off context.
No discovery. MCP assumes you know what you need. There's no marketplace, no trust layer, no way to find "the best skill for this job" across the ecosystem.
No adaptation. MCP resources are static. Skills need to adjust based on runtime context—what's worked so far, what just failed, what the agent learned mid-task.
MCP gives you the basic building blocks, but the skill layer on top of them is still missing.
What should developers build toward?
If you're building agents today:
Package capabilities, not functions. Don't ship a tool—ship the expertise to use it. Include instructions, success criteria, and failure modes.
Design for composition. Your skill will be one of many. Define clear inputs, outputs, and context handoffs.
Build in evaluation. How will someone know your skill works? Include test cases, expected behaviors, reliability metrics.
Assume no human. Design as if there's no one to ask "is this right?" The judgment has to be embedded.
Where does this go?
I expect the industry to converge on skills, because autonomous agents need embedded judgment and tools do not carry it.
We're not there yet. Stack Overflow's 2025 survey found that 52% of developers either don't use AI agents or stick to simpler tools, and 38% have no plans to adopt them. The main barrier is trust rather than capability, since developers are wary of tools that are only "almost right."
The frameworks that win will make skills:
- Discoverable — Find the right capability for the job
- Composable — Chain skills into complex workflows
- Trustworthy — Know they work before you deploy them
Tool calling was a necessary starting point, but agents that work on their own will need skills.
If you're building in this space, I'd like to hear what you're working on—find me on Twitter or LinkedIn.