Ambika Saklani Bhardwaj, Product Leader at Walmart Inc.
Every time your team wants a new AI capability, what’s the instinct? Build a new agent.
Need to search Confluence? Agent. Need to query BigQuery? Agent. Need to draft a Jira ticket? Agent. This ultimately creates dozens of agents, each with its own hardcoded tools, duplicated logic and zero shared infrastructure. You don’t have a platform. You have spaghetti.
The worst form of technical debt in AI systems is duplicated capability baked into isolated agents.
This is agent sprawl, a pattern where every agent reinvents the wheel because there’s no shared layer of reusable, composable skills. Every search tool, every formatter, every API wrapper gets copy-pasted into yet another agent.
The cost? Maintenance hell, governance nightmares, inconsistent behavior and zero leverage.
The Skill-First Philosophy
The antidote to agent sprawl is deceptively simple: Build skills, not agents. A skill is a focused, well-defined, independently deployable capability—basically, a tool that does one thing exceptionally well. A search skill knows how to search. A BigQuery skill knows how to write and execute queries. An email skill knows how to draft and send messages.
Agents become thin orchestrators. They don’t own tools; they borrow skills from a shared registry. When you fix a bug in the search skill, every single agent that uses it gets the fix automatically. When you add a new data source to the BigQuery skill, the entire org benefits instantly. That’s leverage.
The Three Laws Of Skill-First Design
There are three laws of skill-first design:
1. Atomic: Each skill does one thing and does it brilliantly. No god-skills. No Swiss Army knives.
2. Reusable: Any agent in the organization can consume any skill. Zero copy-paste. One source of truth.
3. Composable: Skills snap together like LEGO and can be chained into multistep workflows without reengineering anything.
Enter MCP: The USB-C Of AI
The model context protocol (MCP) is an open standard introduced by Anthropic in late 2024. In my opinion, it’s now the single most important piece of infrastructure for skill-first architecture. Think of it as the USB-C port for AI: one universal connector that lets any AI model talk to any tool, any data source or any service without custom glue code for every pairing.
Before MCP, connecting an LLM to your tools meant writing bespoke integration code for every combination: Claude plus Confluence, GPT plus BigQuery, Gemini plus Jira. With MCP, you write a skill (an MCP server) once, and every MCP-compatible AI host can use it instantly.
This is because MCP decouples the skill from the agent entirely. The search skill doesn’t care if it’s called by Claude, GPT-4, Gemini or your custom agent. The agent doesn’t care how the search skill is implemented. They speak MCP, and that’s all that matters.
Skill Composition: LEGO For AI
The real magic of MCP is what happens when you compose skills. Like LEGO bricks, atomic capabilities snap together into sophisticated multistep workflows without anyone writing new tool code.
For example, two completely different business workflows—say, generating a report and responding to a customer inquiry—can use the exact same Write skill. The Write skill in Workflow A is the same deployed skill used in Workflow B. That’s the leverage of the skill-first model compounding in real time.
Governance, Versioning And The Skill Registry
Building skills once isn’t enough. You need to actually govern them. A skill registry backed by MCP gives you a single control plane for every capability in your org:
• Versioned Skills: Skills are versioned using semantic versioning (SemVer). Agents pin to search-skill@2.1, ensuring breaking changes never reach dependent systems without explicit opt-in.
• Telemetry Built-In: Every MCP tool call is logged. You automatically know exactly which agents call which skills, how often and at what cost.
• Entitlement-Gated: MCP servers enforce identity-aware access. Only authorized agents can call the BigQuery skill. No shadow IT.
• Test Once, Trust Forever: Each skill has its own test suite. When the Jira skill passes CI, every agent that uses it inherits that confidence. One QA pass, org-wide benefit.
The Skills-First Manifesto
• Build Skills, Not Agents: Before writing a single line of code, every new AI use case should start with the question, “Does a skill for this exist?”
• MCP Is The Contract: Skills expose capabilities via MCP. Agents consume via MCP. That’s the only interface that matters.
• One Fix, Infinite Benefit: When you improve a skill, every agent in the organization gets better. That’s the compound interest of good architecture.
• Govern Your Registry: A skill nobody can find is a skill nobody reuses. Catalog, document and version every skill from day one.
• Agents Are Glorified Routers: Keep them thin. Their job is to understand intent and select skills—not to implement capabilities.
Remember, the best AI architecture is the one where building the tenth agent is as easy as the first because all the hard work is already done in the skill layer.
Start with one skill. Build it right. Version it. Document it. Then watch your entire organization build on top of it. That’s the MCP-powered future, and it’s available today.
The Bottom Line
The era of building one agent per problem is over. The teams that will prove most successful in the AI era aren’t the ones with the most agents but the ones with the best skills platforms.
MCP is the protocol that makes this real: an open, universal, transport-agnostic standard that lets your skills be discovered and called by any model, any orchestrator, anywhere.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?
