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

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](https://modelcontextprotocol.io/specification/2026-07-28/server/tools) 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](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp), OpenAI through the [MCP tool in the Responses API](https://developers.openai.com/api/docs/guides/tools-connectors-mcp), and Microsoft through [Copilot Studio](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-add-existing-server-to-agent).

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](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization) 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](https://modelcontextprotocol.io/specification/2026-07-28/server/tools) 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](https://developers.openai.com/api/docs/guides/tools-connectors-mcp) 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](https://modelcontextprotocol.io/specification/2026-07-28/server/tools). 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](https://coil.trade/) 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](https://coil.trade/agents), and [what each one returns](https://coil.trade/learn/mcp-server-stock-scores) 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](https://coil.trade/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](https://coil.trade/agents), where current prices live. Mechanics are in the companion page on [how to monetize an MCP server](https://coil.trade/learn/monetize-mcp-server).

The server is also listed in the [official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=trade.coil) as `trade.coil/stock-market-scanner`, and there is a [Claude directory listing](https://claude.ai/directory/connectors/coil).

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](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp), 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:

- **The official MCP Registry**, the [public metadata catalog](https://modelcontextprotocol.io/registry/about) that aggregators and marketplaces pull from. Coil's entry is `trade.coil/stock-market-scanner`, and it is [visible in the registry API](https://registry.modelcontextprotocol.io/v0/servers?search=trade.coil).
- **An assistant's own connector directory.** Coil is [listed in Claude's connector directory](https://claude.ai/directory/connectors/coil). We have not verified a ChatGPT directory listing for Coil, so this page does not claim one.
- **llms.txt and agents.md.** Plain-text documents at your site root that let an agent read your offer in one fetch. Coil serves [llms.txt](https://coil.trade/llms.txt) and [agents.md](https://coil.trade/agents.md).
- **A server card.** A small JSON description of the server that clients can read before connecting. The location convention is still changing, covered in the [companion page on monetizing an MCP server](https://coil.trade/learn/monetize-mcp-server).
- **x402.** An agent with a wallet can pay per call with no signup, so a first purchase needs no sales conversation. See [the free tools and pay-per-read options](https://coil.trade/agents).

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: the [official MCP Registry](https://modelcontextprotocol.io/registry/about) (in preview, with reverse-DNS names tied to a verified domain), assistant directories, an [llms.txt](https://llmstxt.org/) file, and your own documentation, which answer engines read 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, when the work is visual or spatial, when onboarding needs structure, and when customers want to browse rather than ask.

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.

Coil is research, not investment advice. Nothing here recommends a security or a trade. The FAQ and the full source list are in the original.

*Originally published at* [*coil.trade/learn/saas-as-an-mcp-server*](https://coil.trade/learn/saas-as-an-mcp-server)*. Try a working stock market MCP server free at* [*coil.trade/connect*](https://coil.trade/connect)*.*
