Agent Skills & AaaS: AI’s Universal Adapter & On-Demand Agents

Stop me if this sounds familiar: You’re in the middle of a high-intensity "vibe coding" session, feeling like a digital god, until your AI assistant confidently suggests a library version that hasn't been relevant in a while. Suddenly, the flow is dead, and you're back to manual labour, opening endless documentation tabs just to find the one updated command the AI should have known, or manually clicking through menus to test changes that the AI should have handled in the background.

It turns out that the dream of being a "lazy" architect, watching things happen in the background while you are busy playing Elden Ring, has been hindered by a chaotic mess of custom bridges and data silos. But the game is changing. We are moving from a world where you have to pick up the cards to a world where you hire a professional gambler who already knows every trick and strategy.

1. Deep Dive into MCP

What is MCP?

Ever thought how cool it would be to not even click the buttons or do the operations an AI model instructs you to for your query? Being completely lazy, doing nothing but watching things happen in the background while you continue watching Stranger Things.

In plain English, the Model Context Protocol (MCP) is a universal language that allows an AI to talk to your computer and the internet.

Before MCP, if you wanted an AI to read your files or check your calendar, a developer had to write a "custom bridge" specifically for that task. If they switched AI models, they often had to rebuild the bridge. MCP replaces this chaos with a single, open standard.

In short, MCP’s origin story is about breaking data silos: every new data source used to demand M×N bespoke connectors, MCP cuts that to M+N by standardising the integration.

The crust of the technicality

To understand how MCP actually works under the hood, we need to look at the Host-Client-Server relationship and the JSON-RPC signals used.

1. Main Components

• MCP Host: This is the Environment/Application you are actually using, like Claude Desktop, Cursor, Antigravity (pretty famous these days), or a specialised IDE. The Host is the main character of the movie, who manages security and decides which AI model gets access to which tools.

• MCP Client: This is the Translator inside the Host. It maintains a 1:1 connection to a server and handles the "handshake" to ensure both sides are speaking the right version of MCP.

• MCP Server: This is the main core. It’s a small, lightweight program that knows how to do one thing well, like "Read Google Drive" or "Search a SQL Database." It exposes these abilities to the AI in a standardised way.

2. The Communication (JSON-RPC 2.0)

MCP uses JSON-RPC 2.0, a lightweight "Remote Procedure Call" protocol. Instead of messy, unstructured chat, the Client and Server send strict, numbered messages:

• Requests: "Hey Server #1, run the get_products tool for 'DMart'."

• Responses: "Hey Client #1, here is the data for Request #1: <data>"

• Notifications: "Heads up, the file you were watching just changed!" (No reply needed).

• Format:

  { jsonrpc: "2.0", id: number | string, method: string, params?: object }

If you want to read more about JSON_RPC 2.0 in MCP, refer to this: https://medium.com/@dan.avila7/why-model-context-protocol-uses-json-rpc-64d466112338.

3. The Transport Layer (How the data moves)

• Local (stdio): Used for tools on your own machine. The Host starts the Server as a "child process", and they whisper to each other through the computer's internal pipes. It's incredibly fast and secure because the data never leaves your hardware.

• Remote (SSE): Used for cloud services. It uses Server-Sent Events to keep a "live wire" open between your AI and a remote server, allowing for real-time updates.

MCP Server have a lot of tools whose selection and order of execution are decided by the LLM connected. A simple MCP Server Tool looks like this:

@mcp.tool()
async def get_attendance(student_id: str, date: str) -> str:
    """Get attendance status for a student on a given date."""
    # Implementation details...

Visit the official docs if you want to learn more about the implementation: https://modelcontextprotocol.io/docs.

Although there are some people that are saying that MCP is something that is overhyped. If you look at the registry PulseMCP, there are over 6,600 servers listed, but the number of active enterprise users is still catching up.

2. Agent Skills

Have you ever noticed that while in a vibe coding session of yours, the commands or code getting executed aren't the latest or the most optimal?

You are in the flow, and the AI is hallucinating a library version from the good old days of 2021, and you only realise when you have to open those docs poised in anticipation of your arrival.

Here comes agent skills, first introduced by anthropic.

Now, what is Agent Skills? It's a very simple concept, actually, if we see. Agent skills is a meta tool for conversation and execution context injection with progressive disclosure.

By splitting your agent's knowledge into these three layers, you solve the two biggest problems in AI development:

• Token Bloat: You aren't paying for the agent to "remember" every script in your scripts/ folder until it actually needs to run them.

• Context Drift: Because Level 2 is loaded only when triggered, it acts as a "fresh start" for the agent's logic, ensuring it follows your current documentation instead of its past training.

A good read if you want to learn how to write agent skills for something you’re building or tailor an agent to your needs: https://leehanchung.github.io/blogs/2025/10/26/claude-skills-deep-dive/

Some cool Agent Skills to try:

https://github.com/resend/email-best-practices

https://github.com/supabase/agent-skills/tree/main/skills/postgres-best-practices

https://vercel.com/blog/introducing-react-best-practices

Where MCP Plugs In: The Capability Layer

MCP is the universal connector that allows your Level 3 Resources to actually do something. While your Skill might tell the agent "Update the documentation," MCP is the physical protocol that lets it log into GitHub and push the commit, so you don’t have to move your rusty fingers to do some clicks.

3. Unpacking Agent as a Service (AaaS)

If MCP is the universal hardware port, Agent-as-a-Service (AaaS) is the full-service "robot butler" that plugs into it. Traditionally, Software-as-a-Service (SaaS) meant subscribing to a tool where you had to do the heavy lifting inside their interface.

With AaaS, you aren’t just renting a static tool, you’re renting an autonomous digital worker that lives in the cloud and actually performs the tasks for you.

SaaS vs. AaaS

The shift is a change from “do-it-yourself” to “done-for-you".

Active vs. Passive: SaaS is a sophisticated toolbox that is useful, but it stays quiet until you learn how to use it or hire someone. AaaS agents are "always-on" teammates (they don’t ask for rigid job timings ;) ) that monitor your data, plan their own steps, and execute goals without you constantly poking them.

This brings new ways to do things.

1. New Revenue Models: Paying for Wins, Not Seats

Forget the old "flat fee per user" model that SaaS uses. Since agents do specific work, vendors are shifting to Outcome-Based Pricing.

• Micro-charges: Instead of a $100/month flat rate, you might pay per lead generated or a small fee for every customer ticket successfully resolved.

• Scalability: You only pay for what you actually consume, making it perfect for startups that need to scale fast without the "psychological barrier" of a massive monthly bill.

2. Faster Integrations:

• Efficiency: Building custom connectors used to take months of developer time. With MCP, agents can "plug and play" into your GitHub, Slack, or Google Drive via a single, universal interface.

• Speed: Companies using MCP report saving roughly 30–40% on their integration timelines.

The Casino Whale Analogy

1. The Gambler (The AI Agent)

The gambler is the core brain. They have the intent to win and the ability to make decisions based on what they see. But a gambler without a strategy or a seat at the table is just a person in a fancy suit (probably you)

2. The Cheat Sheet & Strategy (Agent Skills)

This is our 3-layer architecture.

• Level 1 (Metadata): The gambler knows which games are in the room (Poker, Blackjack, Roulette). They don't have the mood or gut feeling which one to play in their head yet, but know where to walk.

• Level 2 (Instructions): Suppose they sit at the Poker table. Now, they “activate” their Poker Skill. They recall the specific rules of this game, the "latest and most optimal" strategy that overrides their general knowledge.

• Level 3 (Resources): This is the mental math. The gambler pulls out a specific "resource", a probability chart for a 52-card deck, poker hand combinations, etc., to calculate the exact odds of the current hand.

3. The Keycard & The Chips (MCP)

The gambler has the skill, but they can't play without access.

• MCP is the Casino Keycard. It lets the gambler through the door, identifies them to the pit boss, and connects them to the house's data (the cards being dealt).

• Without MCP, the gambler is just gambling in the mind. With MCP, they are plugged into the table's live feed.

4. The Winning Hand (Agent-as-a-Service)

In the old world (SaaS), you were the gambler. You had to buy the strategy book and sit at the table yourself. In terms of AaaS, you are just the Backer. You don't play the game, you simply hire the pro gambler, give them the MCP keycard to your accounts, and they play 24/7. You don't care about the individual card flips, you only care about the chips stacking up in your vault.

Human Upgrades: Does this mean we lose our jobs?

(Only applicable if you have one right now)

We aren't just losing repetitive roles, but we are evolving them to ship stuff faster.

There is a shift that is happening, and we can see that by considering the layoffs going on.

Roles like Agent Supervisor, Prompt/Task Engineers for humans who oversee "fleets" of Agents. Instead of doing the data entry, mailing, and logging, you monitor the agents for the edge cases and step in only when things get complicated.

Strategic Oversight: Humans move from being "order-takers" to "strategic planners," focusing on high-level goals like system designs while the agents actually get their hands dirty (no, we are not calling them slaves).