Why We Built an MCP Server for Software Licensing

What MCP Actually Is

If you haven't encountered MCP yet, here's the short version: Model Context Protocol is an open standard that lets AI assistants use external tools. Think of it like a USB port for AI. An MCP server exposes a set of capabilities — reading data, creating resources, taking actions — and any compatible AI client can plug in and use them.

In practical terms, this means your AI coding assistant (Cursor, GitHub Copilot, Windsurf, Claude) can do more than just generate code. It can interact with real systems. Query a database. Create a resource. Check a status. The AI doesn't just suggest what to do — it actually does it, with your approval.

MCP servers are showing up across the developer ecosystem — for databases, cloud providers, CI/CD systems, and now billing. We wanted one built specifically for licensing: for setting up what you sell and wiring it into your code.

The Builder's Workflow Has Changed

Two years ago, a developer setting up software licensing would open a dashboard, click through forms, copy API keys into config files, and manually wire up enforcement code. That workflow still works. But it's increasingly at odds with how developers actually build software today.

The modern development workflow is conversational. Developers describe what they want, and AI generates code, configures services, and wires things together. The IDE is becoming the command center, and the AI assistant is the co-pilot (literally, in some cases).

Here's the problem: if your licensing platform doesn't have an AI integration surface, every interaction with it becomes a context switch. You leave your IDE, open a browser, navigate to a dashboard, click through forms, copy values back into your code. Multiply that by every product change, every tier adjustment, every license query. It adds up fast.

We asked ourselves: what if the AI could just handle this? What if — instead of switching to a dashboard — you could tell your assistant "create a Pro tier with access to advanced analytics and export features" and it would just do it?

What Our MCP Server Does

Monaiq's MCP server exposes the setup side of the platform as a set of tools your AI assistant can call. Here's what that looks like in practice.

Product management: Create and configure products, define features (boolean access, rate limits, and allowances of so many uses per billing period), and set up offerings with pricing — all through natural language conversation.

What it deliberately leaves out: licenses, seats and license codes are not MCP tools. They are created by a purchase and managed in the portal or from your own backend, where a change that moves money is confirmed by a person.

Code generation: The AI can generate enforcement code tailored to your product's specific feature set. Not generic boilerplate — actual integration code that references your real product and feature identifiers.

Here's an example of what an MCP tool invocation looks like under the hood:

{
  "name": "product",
  "arguments": {
    "action": "create",
    "data": "{\"Code\": \"ANALYTICS_PRO\", \"Name\": \"Analytics Pro\",
             \"Description\": \"Advanced analytics platform\", \"Status\": \"Draft\"}"
  }
}

You don't write this JSON. Your AI assistant formulates it based on your natural language description. You see the result, approve it, and the product exists in Monaiq. Its features and offerings follow the same way, through the product_feature, offering and feature_offering tools.

Why It Is Not Just a Wrapper

When we looked at the landscape, most AI integration in this space was an API with a protocol bolted on.

Keygen, the closest pure-licensing competitor, has built an excellent API-first platform. Their focus is on API design purity — REST conventions, clean resource modeling, predictable behavior. That's a valid architectural philosophy. But it's optimized for human developers writing HTTP calls, not for AI agents that think in terms of tools and capabilities.

Lemon Squeezy and Polar are optimized for the payment experience — checkout flows, digital delivery, merchant-of-record tax handling. Polar ships an MCP server of its own, built around that billing surface. Our tools are built around the other half of the job: deciding what a license unlocks and putting the check in your code.

Building an MCP server isn't just "wrap your API in a new protocol." It requires designing your tools from the AI's perspective. What information does the AI need to make good decisions? How granular should each tool be? What context should flow between tool calls? These are different design questions than "what should the REST endpoint look like?"

We had an advantage here: Monaiq was built with AI integration as a first-class concern, not retrofitted onto an existing API. The MCP server didn't require us to change our architecture — it was a natural extension of it.

What We Learned

Building the MCP server taught us something we didn't expect: AI agents are terrible at multi-step wizards.

Our initial design mirrored the dashboard experience — create a product first, then add features, then create an offering, then attach features to the offering. Step by step, just like a human would do it in a UI. The AI could follow the steps, but it was clunky. Every step required the AI to remember context from the previous one.

The breakthrough was making each tool explain itself. Every catalog tool takes one action and one JSON payload whose schema travels with the tool. A refusal names the exact shape it expected, with an example, and an optional idempotency key means a retried call never does the work twice. Guidance tools hand back the next step instead of leaving the AI to guess it.

This is a general lesson for anyone designing AI-facing APIs: a tool that says what it wants, and what went wrong, is worth more than a clever one. The AI doesn't need hand-holding — it needs tools that answer in its terms.

We're still learning. The MCP ecosystem is evolving fast, and our server will evolve with it. But the core bet — that AI-native developer tools are the future — feels more right with every interaction we see.