Live MCP Tools and Agent Skills: Building for the Agentic Web

The Shift from Developer Tools to Agent Tools

Something fundamental is changing in how software gets built and used. The rise of vibe coding — building applications by describing what you want rather than writing every line — has compressed the distance between an idea and a working product. Tools like Cursor, Claude Code, and Windsurf have turned AI from an autocomplete feature into a genuine collaborator.

But vibe coding is just the beginning. The next wave is agentic engineering: AI agents that don't just help developers write code, but that autonomously discover, evaluate, and integrate external services to accomplish goals. An agent building a DeFi lending app doesn't just need help writing React components — it needs to assess whether a borrower is creditworthy.

That's why we've shipped two things this week: live MCP endpoints for real on-chain credit data, and a unified agent skill file that teaches any MCP-connected agent how to use them.

What We Shipped

Live MCP Endpoints

Until now, our MCP server only exposed sandbox tools — mock data that's great for development but useless for production decisions. Today, agents can access the real thing:

• get_live_credit_score — Real credit scores (300-1000) computed by the Andromeda 1.0 model using actual on-chain data across 10+ chains
• get_live_financial_summary — Comprehensive multi-chain financial reports including assets, debt, DeFi positions, liquidation history, and global percentile rankings
• get_live_identity_attestations — Verified identity credentials (ENS, Gitcoin Passport, POAPs, Worldcoin, BrightID) fetched from real blockchain networks

These endpoints work through both the MCP protocol (for AI agents like Claude and Cursor) and standard HTTP (for any application). Authentication uses the same API key you already have from the Cred Protocol Dashboard.

Agent Skill Instructions (SKILL.md)

Giving an agent access to tools isn't enough. An agent with nine available tools and no guidance will either call the wrong one, call too many, or misinterpret the results. That's the problem our new agent skill file solves.

When an AI agent connects to the Cred Protocol MCP server, it automatically receives structured instructions that cover:

• Tool selection — A decision table mapping user intents to the right tool. "Is this wallet trustworthy?" routes to get_credit_score. "Tell me everything about this wallet" routes to get_financial_summary.
• Escalation patterns — Start with a cheap score check, escalate to a full report only when needed. Don't over-call.
• Score interpretation — What each score range means, how to read the six credit factors, and what constitutes a red flag.
• Best practices — Batch when possible, interpret don't just relay, flag liquidation history and missing identity attestations.

These instructions are delivered via the MCP instructions field during initialization — no configuration needed. The agent just connects and knows what to do.

Why This Matters Now

Agents Are the New API Consumers

The traditional API workflow looks like this: a developer reads the docs, writes integration code, handles errors, parses responses, and builds business logic around the data. It works, but it's a bottleneck. Every new integration requires a human developer to understand the API and wire it up.

With MCP, that bottleneck disappears. An agent can discover available tools, understand their parameters, call them with real data, and interpret the results — all without a developer writing integration code. The agent is the integration layer.

This isn't theoretical. Today, an agent running in Cursor or Claude Desktop can:

1. Connect to the Cred Protocol MCP server
2. Receive skill instructions automatically
3. Look up a real credit score for any Ethereum address
4. Pull a comprehensive financial report
5. Make a lending decision or risk assessment

No npm install, no SDK, no integration sprint. Just a natural language request and real-time on-chain intelligence.

Vibe Coding Needs Real Data

Here's a scenario that's already happening: a founder describes a DeFi lending protocol to an AI coding agent. The agent scaffolds the smart contracts, builds the frontend, and sets up the backend. But when it gets to the underwriting logic — deciding who gets a loan and at what terms — it hits a wall. Without access to real credit data, the agent either hardcodes dummy logic or stops and asks the developer.

With live MCP tools, the agent doesn't stop. It connects to Cred Protocol, pulls the borrower's credit score and financial summary, and writes underwriting logic grounded in real data. The vibe coding session doesn't break because the agent has the context it needs to make informed decisions.

Agents Finding Analytics for Themselves

The most interesting use cases aren't the ones where a developer tells an agent to use Cred Protocol. They're the ones where the agent discovers it on its own.

Consider an autonomous treasury management agent tasked with deploying capital across DeFi protocols. It needs to evaluate counterparty risk, assess borrower creditworthiness, and monitor portfolio health. With MCP discovery, it can find Cred Protocol's tools, understand what they do (via the skill instructions), and start using them — all without explicit human direction.

Or consider a customer support agent for a lending platform. A user asks "why was my loan application denied?" The agent pulls their credit score, identifies the weak factors (maybe low borrowing history and thin wallet composition), and gives a specific, actionable answer — not a generic "please try again later."

Other use cases emerging right now:

• Automated credit monitoring — Agents that periodically check scores for a watchlist of addresses and alert on significant changes
• Multi-sig risk assessment — Batch-scoring all signers of a multi-sig wallet before approving a transaction
• Portfolio due diligence — An investment agent evaluating a basket of DeFi positions across chains before recommending allocation
• Identity-gated access — Agents that verify attestations (ENS, Gitcoin Passport) before granting access to premium features
• Agent-to-agent trust — One agent evaluating the on-chain reputation of another agent's wallet before transacting

The Skill File Pattern

We think the pattern we've established with SKILL.md will become standard for API providers building for the agentic web. The key insight: tool descriptions tell an agent what a tool does, but skill instructions tell it when and how to use them well.

A tool description says "get_credit_score returns a score between 300 and 1000." A skill instruction says "start with get_credit_score when the user asks about wallet trust, use include_factors for detail, and only escalate to get_financial_summary if they need the full breakdown."

The difference is the same as giving someone a wrench versus teaching them to be a mechanic. Both matter, but the teaching is what makes the tools useful.

If you're building APIs that agents will consume, consider publishing your own skill files. The format is simple: a markdown document that ships with your MCP server, delivered via the instructions initialization field. No new protocol, no new spec — just good documentation in the right place at the right time.

Get Started

If you're building with AI agents and need on-chain credit intelligence:

1. Get an API key from the Cred Protocol Dashboard
2. Connect your agent via MCP (see the Getting Started guide)
3. Review the agent skill at docs.credprotocol.com/mcp-services/agent-skill
4. Explore the tools in the MCP Tools Reference

Sandbox tools are free and require no API key — start testing in minutes. Live tools consume Cred Units and return real blockchain data.

The agentic web is being built right now. The APIs that agents can discover, understand, and use autonomously will be the ones that win. We're making sure on-chain credit intelligence is one of them.