← Learn
AGENT ECONOMY

SaaS as an MCP Server: The Margin Case, With a Live Example

SaaS as an MCP server: why reselling tokens squeezes margins, what you keep, what you hand off, and how one live business already runs this way.

Guide · November 14, 2026 · 14 min read

A growing number of founders are asking whether their product should be an MCP server instead of an app with its own chat assistant. The argument is simple. Expose your data, your business logic and your permissions as tools. Let the customer's own assistant do the talking. Keep charging for the thing only you have.

The thesis, in one paragraph: in this market a software company is either an MCP server or an MCP client. The clients are the assistants people already use, including ChatGPT, Claude, Copilot and Gemini, and they are not going to be built by you. The open position is the server those assistants reach for. What earns that position is a clean interface to private data and proprietary workflows. A polished screen matters much less.

This page works through that argument for a founder or CTO: where the margin case holds, what you keep, what you hand off, and what the model does not fix. It ends with a live example, because most writing on this topic is opinion and this one can point at a working server.

Should SaaS become an MCP server?

For many products, an MCP server should exist. Whether it should replace the app is a different question, and the honest answer depends on who does the work in your product.

The Model Context Protocol lets a server expose tools that a language model can discover and call. A customer connects the server to an assistant they already use, such as Claude, ChatGPT or Microsoft Copilot, and that assistant calls your tools when the conversation needs them. All three vendors document how to connect a remote MCP server: Anthropic through custom connectors, OpenAI through the MCP tool in the Responses API, and Microsoft through Copilot Studio.

The model is strongest where your product is a system of record, a body of proprietary data, or a rules engine, and where the app's main job is to let a person ask questions about it. It is weakest where the interface itself is the product: design tools, creative software, anything built around direct manipulation.

Why AI chat wrappers have thin gross margins

Most SaaS companies that added an assistant did the obvious thing. They put a chat panel inside the product, called a model provider's API, and absorbed the cost.

The structural problem is the shape of the cost. A subscription is a flat price. Inference is a metered cost that rises with use. A customer who asks twenty questions a day costs the vendor more than one who asks two, and both pay the same. The vendor also does not set its own cost of goods: the model provider does. When the provider changes pricing, the vendor's margin changes with it, and the vendor usually cannot pass that through without reopening a contract.

Three things make this worse over time.

First, usage grows. Once an assistant is useful, people lean on it, and the heaviest users tend to be the most valuable accounts.

Second, context grows. A useful assistant reads more of the customer's data on each turn, and longer inputs mean more tokens per answer.

Third, customers compare. Their general-purpose assistant is already open in another tab. A weaker, embedded assistant has to justify itself against it, which pushes vendors toward bigger models and more tokens to keep up.

None of this means a built-in assistant is a mistake. It means the gross margin on that feature is structurally different from the margin on the rest of the software, and a company that reports one blended number can hide it for a while.

What an MCP-first SaaS keeps, and what it hands off

An MCP server changes who pays for the model, and usually who owns the conversation. It does not change who owns the data.

What you keep:

  • The data and the system of record. The assistant reads from you. It does not replace the database.
  • The business logic. Calculations, policy checks and validation live in your tools, so every assistant gets the same answer.
  • Permissions. Your server decides what each signed-in user may see or change. The MCP specification builds authorization on OAuth, and says a server must validate that a token was issued for it and for no other service.
  • Compliance and audit. Logging, retention and approval records stay on your side of the wire.
  • The billing relationship. The customer still signs in as your customer and still pays you.

What you hand off:

  • The conversation. Wording, follow-up questions and summaries come from the customer's assistant.
  • Model choice and model cost. The customer's assistant plan or API account generally carries the inference bill.
  • Most of the front-end. Screens that existed mainly to answer questions can shrink or go.

Note the word "generally". Whoever connects the server decides how it is run. A company that deploys your server inside its own agent platform pays for that platform. The point is that you are no longer the one metering tokens.

A worked example: HR software as an MCP server

This example is illustrative. It describes a hypothetical HR vendor, not a real product.

Consider a company that sells compensation and workforce planning software. Its value is a set of benchmark datasets, a policy engine and a system of record for employees, pay bands and approvals. Its current app has a chat panel that answers questions about all of that, and the inference bill is a growing line in its cost of revenue.

As an MCP server, the same company might expose tools like these:

  • Salary benchmarks. A tool takes a role, level and location and returns a band with its source and date. The data stays proprietary. The assistant only ever sees the answer to the question asked.
  • Pay equity. A tool runs the vendor's analysis over a team and returns the gaps and the method used. The calculation stays in the vendor's code, which matters because an assistant should not be improvising statistics on payroll.
  • Budget modeling. A tool takes a proposed raise pool and returns the effect on each budget. The assistant can then discuss options with a manager in plain language.
  • Promotions under policy. A tool checks a proposed promotion against the company's own rules and returns which rules pass, which fail, and why.
  • HRIS updates. A tool proposes a change to an employee record. This is where design matters most, and it is covered below.
  • Approvals and audit trails. A tool lists pending approvals and returns who approved what, when.

Read tools and write tools are different products. Read tools can be broad and cheap to run. Write tools change records that people depend on, so they need narrower scopes, explicit confirmation and a full audit trail. The specification says there should always be a human in the loop with the ability to deny tool invocations, and lists input validation, access controls and rate limiting as things servers must do. OpenAI's documentation states that its API asks for approval by default before data is shared with a remote server.

A sensible HR build is read-only first. Benchmarks, pay equity and budget modeling carry the value. HRIS writes come later, as proposals a named person approves, with the approval recorded in the vendor's own system.

Permissions deserve one more point. The spec allows the list of tools a server returns to vary with the authorization presented. A manager can see tools for their own team. An HR administrator sees more. The assistant never gets a tool it should not have.

A live example: how Coil runs this way

Coil is a research publication: a scored board of 650+ US stocks and ETFs. It is not software that wraps a chat assistant. It is served as an MCP server at https://mcp.coil.trade/mcp, and a customer's own assistant does the reading, comparing and explaining. This page does not state Coil's revenue, margins or customer numbers, because the point here is the structure.

The server has three ways in.

Free sample tools. Anyone can connect with no key, no account and no payment. The free tools return a sample of the board's morning read: three names per book with headline fields. Tools cover the market regime, a buy list, single-stock reads, sector reads, market leaders, rotation, hold state and a crypto trend gate. The sample exists so an assistant, and the person behind it, can see what the server returns before anything is paid. The free tools are listed here, and what each one returns is documented separately.

A subscription behind OAuth. Coil Live is the full feed and the versioned rulebook. A client that calls a Live tool is sent through an OAuth sign-in. Coil checks the subscriber's licence and issues a short-lived token. The token lasts an hour, and each refresh re-checks the licence, so a cancelled subscription loses access within the hour. The access steps are written out in auth.md.

Pay-per-read over x402. An agent with a wallet can pay for a single read with no account and no key. The server answers with an HTTP 402 and payment terms, the agent pays, and the identical request returns the data. Prices run from a tenth of a cent to five cents a read, as stated on the agents page, where current prices live. Mechanics are in the companion page on how to monetize an MCP server.

The server is also listed in the official MCP Registry as trade.coil/stock-market-scanner, and there is a Claude directory listing.

What matters for the margin argument is the division of labor. The server returns scored data. The customer's assistant does the reasoning and the explaining, on the customer's own plan. Coil is paid for the board, for access, and for single reads, and it does not resell model usage.

Why a read-only server is the safer first product

Coil's server has no write tools. It has no brokerage tools at all. It cannot see, hold or trade an account. If a customer's agent places an order, it does so through the customer's own broker connector, and Coil never sees it.

That is a deliberate design choice, and in a regulated field it is the safer first product for three reasons.

  • The failure mode is bounded. A wrong read is an annoyance that a person can check. A wrong write moves money or changes a record. Starting with reads means the worst outcome of a bad tool call is a bad answer.
  • Liability stays clear. Coil is research, not investment advice, and every payload is the same for every subscriber. A server that never takes an action cannot be mistaken for one that manages money.
  • The host's own controls have less to guard. The spec expects clients to prompt users before sensitive tool operations, and OpenAI's API asks for approval by default. A read-only server gives those prompts little to protect against.

An HR, finance or health vendor can follow the same order. Ship the reads, learn how customers use them, and add writes only where a named human approves each action.

How MCP servers get picked inside ChatGPT and Claude

An assistant does not choose a server on its own from the open web. A person, or a company's administrator, connects it. So the real question is how your server ends up in front of the person who connects it. There are two paths.

Path one: the sale. You sell the software the usual way, and the customer turns on your connector in their assistant. The assistant then calls your tools when a question needs them. This is the dependable path for a B2B product, because the buyer already trusts you and the permissions already exist. On Claude's Team plans, only Owners and Primary Owners can add connectors, and Enterprise limits it to a defined set of roles, so expect an administrator in the loop. Your job is to make the server easy to add: one URL, OAuth sign-in, and a clear list of what each tool does.

Path two: discovery without a sale. Someone who has never heard of you finds the server through a catalog, a document or an agent. The channels:

Path two does not replace path one. It feeds it: a free sample tool gets tried, a pay-per-call read gets bought once, and some of those buyers become subscribers. Neither path is automatic. A listing makes a server findable, and the person connecting it still has to trust it.

What an MCP server does not fix

An MCP server fixes how your product is consumed. It does not create demand.

Agents still have to find you. A customer who has never heard of your company will not type your server's URL into their assistant. Discovery is its own job, and it has pieces:

  • The official MCP Registry is the metadata catalog for public servers. It is in preview, and it uses reverse-DNS names tied to a verified domain or GitHub account, so a name like trade.coil/... can only be published by the owner of that domain.
  • Assistant directories, such as the connector directory Claude offers, put your server where users already look.
  • A plain-text file at your site root, llms.txt, gives an agent a map of your site. It is a community proposal rather than a formal standard.
  • Your own documentation still matters. Answer engines read it when someone asks which tools exist.

Trust is on you. Anthropic's help center warns users to only connect servers built and hosted by organizations they trust, and OpenAI's documentation notes that a malicious server can exfiltrate data from anything that enters the model's context. If you are a new vendor, expect questions about who you are and what your tools can touch.

Standards are still moving. The current specification revision is dated 2026-07-28, and it changed the Streamable HTTP transport by removing protocol-level sessions and the standalone GET stream. Authorization remains optional in the spec. Build against the current revision and plan for changes.

Pricing is yours to design. The protocol says nothing about money. You choose whether to give tools away, charge a subscription, charge per call, or all three.

When a UI still earns its place

An MCP server does not mean the interface disappears. A human still has to check the work, and the spec itself assumes they will.

A UI earns its place when:

  • A person must verify before acting. Approvals, sign-offs and anything a regulator may ask about are better shown on a screen with the record beside them.
  • The work is visual or spatial. Dashboards, layouts and drag-and-drop planning do not translate well into a text conversation.
  • Onboarding needs structure. First-time setup, billing and permission management are easier in a form than in a chat.
  • Customers want to browse. Some questions are not known in advance. A person scanning a board finds things they did not think to ask for.

The likely shape is a smaller app for the human tasks, plus a server for the agent tasks, with both drawing on the same data and the same permission checks. Coil works this way: the same board is available to read in a browser and to query over MCP.

FAQ

Should my SaaS become an MCP server?

Probably, as an addition, if your product holds data or logic that a customer would want their own assistant to use. Replacing the app is a bigger decision and depends on how much of your value is the interface. Start with read-only tools and watch how customers use them.

Does an MCP server improve SaaS gross margins?

It can, because the vendor stops paying for inference on every customer question. The structural reason is that a flat subscription sits against a metered model cost. Whether the margin improves in practice depends on what else you pay for, such as hosting, support and data licensing.

Who pays for the tokens when a customer uses my MCP server?

Usually the customer, through the assistant plan or API account they already use to run the conversation. If a customer deploys your server inside their own agent platform, that platform's bill applies. You pay for serving the tool call, not for the model that reasons about the result.

Is a read-only MCP server enough?

For many products, yes, and it is the safer place to begin. Reads carry the value in research, benchmarking and reporting. Add write tools only where the action is worth the risk, and require a named human to approve each one.

How do MCP servers get picked inside ChatGPT or Claude?

A person or an administrator connects them, so the assistant does not pick a server unprompted. The server gets in front of that person either through a sale, where the customer turns on your connector, or through discovery: the official MCP Registry, an assistant's connector directory, llms.txt, agents.md, a server card, and pay-per-call access over x402.

How do customers find an MCP server?

Through the official MCP Registry, assistant directories, your own documentation and an llms.txt file. A server alone does not bring demand. Treat discovery as a separate piece of work.

Coil is research, not investment advice. Nothing on this page recommends a security or a trade.

Sources

Educational research only. Nothing here is a buy or sell recommendation, financial advice, or a promise about any market. Figures are as of the dates shown and sourced above; decide for yourself, or talk to a licensed adviser.

Try a working MCP server

Coil is a stock-research MCP server: a scored board of US stocks and ETFs that your assistant reads. The free tools need no key and no account, Coil Live adds the full feed behind sign-in, and agents with a wallet can pay per read over x402. More on how Coil works for agents.

Connect Coil to your AI — free

Coil is software and impersonal research, not investment advice. It is not a managed account and not a signal service. Markets can lose money, and leveraged ETFs can lose value rapidly, including total loss. Backtested research is not a promise of returns.