Agents Need a Language. MCP Is It

One of the most common use cases I deal with at Kanmon is our Credit Limit Increase Program (CLIP). Periodically, I review a business’s credit limit with us and proactively push increases. Our users also frequently reach out to request limit increases themselves. CLIP helps me manage risk and growth—essentially, I get to reward responsible borrowers and grow alongside them.

This feature blends automation with a human-in-the-loop approach. At a high level, I use a defined model that evaluates various factors about a business and suggests whether to increase the credit limit, and by how much. A human (often me or someone on our team) steps in not just to approve the decision but to request any supplemental data the model might need—since every business has its quirks. This human review phase also helps me gradually fold more edge cases into the model over time. It’s how I continuously make exceptions part of the rule.

I started exploring LLMs and agentic systems to supercharge this workflow. My goals were to:

• Make the process fully automated and real-time
• Make model updates faster and easier
• Decouple components so I could ship faster with less friction

CLIP Agent V1

The first version was pretty straightforward:

• I expressed the model logic as natural language prompts, which made updating or adding edge cases a breeze
• I wrapped my data sources as tools so the agent could call them
• I ran the agent on a schedule, but also allowed it to be triggered on-demand by user requests

I wrote all the infra code myself instead of relying on frameworks like LangGraph. I wanted complete control and a deeper understanding of how everything worked under the hood.

While V1 worked, I quickly ran into issues. It was too tightly coupled. Every time I wanted to change how I accessed data or add a new connector, I had to dive into the agent codebase, register the tool, and handle the call logic. Adding a new front-end meant redeploying code just to support a new client.

Then I found MCP.

---

Why MCP Changed Everything

You can read more about it here, but here’s the gist:

MCP is an open protocol that standardizes how applications provide context to LLMs. It’s like a USB-C port for AI—unifying how models plug into tools and data.

It radically simplified my architecture.

MCP solved four huge problems for me:

1. Auto-discovery1: All tool calls are exposed via the MCP server. Clients no longer need tools to be hardcoded—they discover them on the fly.
2. Standardized tool execution2: No more tweaking the tool interface. Add a new tool and it “just works.
3. Easy client integrations: New clients only need to know how to send a request and where my MCP server lives. Everything else—discovery, execution—is handled automatically.

Easy LLM switching: MCP lets me store/bind prompts to tool calls, so swapping out the underlying LLM is trivial. My business logic stays cleanly abstracted.

Thanks to MCP, I was able to extend this workflow into Claude Desktop and Slack for our ops team—fast.

---

Is MCP the Future?

I think so.

I’m especially excited about elicitation, a new feature in the latest spec. I’ve started using it in Slack workflows for human-in-the-loop tasks like confirming or editing inputs for ops requests (e.g. payment extensions). It’s a killer abstraction that fits how I think about agent design.

After building multiple systems in this space, I’m convinced: MCP is the only agent-to-agent protocol that actually fits how real agents work. All agents need to discover tools, execute them, and involve humans. MCP nails all three—with an ecosystem that’s only getting stronger.

MCP is all you need

Footnotes:

Tool discovery is just post request

# Send MCP tools/list request
            response = requests.post(
                f"{self.server_url}/mcp/",
                json={
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "tools/list",
                    "params": {}
                },
                headers={
                    "Accept": "application/json, text/event-stream",
                    "Content-Type": "application/json"
                }          

Tool execution is also just a post request

response = requests.post(
               f"{self.mcp_server_url}/mcp/",
               json={
                   "jsonrpc": "2.0",
                   "id": 1,
                   "method": "tools/call",
                   "params": {
                       "name": tool_name,
                       "arguments": arguments
                   }
               },
               headers={
                   "Accept": "application/json, text/event-stream",
                   "Content-Type": "application/json"
               },
               timeout=30
           )