MCP servers for AI agents: how agents discover and execute tools

An agent is only as useful as the tools it can reach. MCP, the Model Context Protocol, is the interface most clients now use to expose tools to a model. This post explains how MCP works in practice, how it differs from a plain REST API and from A2A, and how Fikra exposes its paid inference and fixed-price tools over it.

What MCP is

MCP is a JSON-RPC protocol between a client (the app running the model) and a server (the system that owns the tools). The client asks the server what tools exist, then calls them. The model never talks to your server directly. It asks the client, and the client makes the call.

A session starts with initialize, then the client sends notifications/initialized. From there the two methods that matter are tools/list and tools/call.

Discovery

tools/list returns every tool with a name, a description and a JSON Schema for its arguments. Good descriptions name the user intention, not the endpoint. If the description says "POST /v1/things", a model has to guess what that means. If it says "Extract invoice fields into structured JSON", it can choose correctly.

{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}

Fikra returns 65 tools today: chat, quote, model listing, six account and billing tools, and 48 fixed-price task tools across documents, contracts, recruitment, creator, developer, audio and productivity.

Execution

tools/call takes a tool name and arguments. The server runs it and returns content blocks. For a paid tool, the price should be visible before the call, either in the tool description or through a free price endpoint.

{"jsonrpc":"2.0","id":2,"method":"tools/call",
 "params":{"name":"fikra_extract_invoice_fields",
           "arguments":{"document":"Invoice INV-77 from Acme Ltd. Total USD 250.00."}}}

The result is structured JSON plus a receipt id. The receipt lets the caller reconcile a charge against the work.

MCP versus REST

REST is a contract between two programs. MCP is a contract between a model and a tool set. If a human or a service calls your API, REST is simpler. If a model chooses tools at runtime, MCP gives it the schema and descriptions it needs to choose. Fikra serves both from the same implementation, so behaviour and prices match: /v1/mcp for agents, /v1/products/{id} for direct calls.

MCP versus A2A

MCP connects a model to tools. A2A connects agents to other agents, with a task lifecycle. They solve different problems and can coexist. Fikra exposes message/send over A2A for agent-to-agent calls and the full tool set over MCP.

Authentication and billing

Three credential types work: a prepaid API key (fk_live_...), a delegated agent token, or an x402 payment signature. Discovery calls are free. Paid calls return a price first and charge only on success.

Security

Treat tool arguments as untrusted input. A document passed to an extraction tool can contain instructions. The server must treat document content as data, not commands. Every tool should enforce account isolation, input limits and idempotency, and write an audit row. A paid tool should never be marked read-only.

Try it

The directory of live tools is at /tools. The MCP integration page explains endpoints and authentication: /integrations/mcp. For creating an account from an agent, see Agents for humans.