Extensible Software vs. The API Tax: What Is Extensible Software AI?

The short answer

Extensible software AI means applications built so an AI agent can read the actual code, data model, and logic, then modify or extend them directly, instead of poking the system through a narrow, metered API. Instead of a vendor deciding what you're allowed to touch, the agent can add a field, write a new report, or wire up a workflow because it can see and edit the real thing.

This is a break from the last twenty years of SaaS, where every integration meant begging a vendor's API for scraps of access, then paying per call for the privilege.

The API tax, explained

For a decade, most software companies charged for integration the same way: per request. Simple to bill, simple to understand.¹ It is also, according to API infrastructure company Zuplo, increasingly the wrong model. Pay-per-call pricing punishes efficient engineering, since a developer who caches responses and batches calls pays less than one who hammers the API with redundant requests, even though the sloppy customer often costs the vendor more to serve.¹ It also creates budget anxiety: finance teams hate that one bad integration or viral spike can blow up a bill overnight.¹

That is the API tax. You pay per call, per seat, and per rate-limit tier, and none of those numbers reflect the value you actually got. A typical mid-market company already spends around $35,000 a month, or roughly $422,000 a year, renting a stack of SaaS tools like a CRM, monitoring, support desk, and a dozen smaller line items. APIs are the connective tissue of that stack, and every connection point is another toll booth.

Why agents change the math

Large language models do not just consume APIs faster. They change what "integration" even means. Anthropic's Model Context Protocol (MCP), open-sourced in November 2024, gave AI assistants a standard way to connect to the systems where data actually lives, replacing one-off custom integrations with a single protocol.² Anthropic described the old approach bluntly: every new data source required its own custom implementation, making truly connected systems hard to scale.²

The uptake has been fast. Public MCP server directories now list more than 20,000 servers, and one tracking service estimated local MCP servers were downloaded 67 million times in a single month in 2026.³ A Zuplo survey of nearly 100 technical professionals found 72% expect their MCP usage to increase over the next year, and 70% of MCP users already have between two and seven servers wired into their workflow.⁴ One enterprise, Workato, reported a 700% jump in daily Claude usage after connecting read-only MCP servers to give the model real context.³

But MCP servers are still, in the majority of cases, just a wrapper around an existing API. Zuplo's own data shows 58% of MCP builders are creating MCP wrappers around APIs they already had, not building anything fundamentally different.⁴ That is a real improvement in access. It is not the same as extensibility. A wrapped API still enforces the vendor's rate limits, the vendor's schema, and the vendor's idea of what you are allowed to do.

Extensible software goes one layer deeper

Extensible software AI is the next step past "give the agent an API key." It means the underlying application is structured so the agent can read the actual source, the actual data model, and the actual business logic, and change them. No wrapper, no rate limit, no waiting on a product roadmap you cannot see.

Concretely, this looks like:

• Code the agent can read and write directly, typically standard, version-controlled code in a language like TypeScript, rather than a black-box binary behind an API gateway.
• A data model the agent can extend, adding a field or a table without filing a support ticket.
• Native interfaces beyond a single REST API, including web, HTTP API, MCP, email, webhooks, and cron, so the agent picks whichever channel actually fits the task.
• No metered toll on every action, because the agent is operating on software you run, not a subscription you rent by the call.

Anthropic's own engineering team found a version of this efficiency gap when it tested code execution against traditional tool calls: in one Google Drive-to-Salesforce example, letting an agent write and run code against MCP tools cut token usage from about 150,000 tokens to 2,000, a 98.7% reduction. The lesson generalizes past MCP specifically. When an agent can act on a system directly instead of negotiating every step through a rigid interface, both cost and friction collapse.

The security tradeoff nobody skips past

None of this is free of risk, and skepticism here is earned, not paranoid. Half of MCP server builders cite security and access control as their single biggest challenge, and 38% say security or compliance concerns are actively blocking wider adoption.⁴ Independent research is worse: one security firm found 43% of tested MCP servers contained command injection flaws, a serious remote-code-execution risk, and another analysis of over 5,000 open-source MCP implementations found 53% relying on insecure, long-lived static credentials like API keys instead of OAuth.³

Extensible software does not remove that risk automatically. If anything, giving an agent write access to real code and real data raises the stakes on identity, permissions, and audit logging. The systems worth building on for this reason treat governance as a first-class feature, not an afterthought: managed authentication, immutable audit logs, and defined data residency, the same boring checklist a security team already asks about for any new SaaS vendor.

Own it or wrap it

The practical choice most teams face isn't whether to adopt MCP. It's already the default connective layer, and it's not going anywhere. The real choice is whether your internal software stays something you can only reach through someone else's rate-limited API, or something an agent can extend directly because you own the code. Tools like Remy are built around that second bet: instead of wrapping a rented SaaS tool in yet another connector, the software itself is standard, agent-editable code that runs on infrastructure you control from day one.

That distinction is the whole article in one sentence. An API gives an agent a keyhole. Extensible software gives it the room.

FAQ

What is extensible software AI in one sentence? It is software architected so an AI agent can read and modify the actual code and data model, not just call a limited, metered API on top of it.

Is MCP the same thing as extensible software? No. MCP is a standard protocol for connecting an AI agent to a tool or data source. Most MCP servers today are wrappers around existing APIs, so they inherit the same rate limits and access restrictions the underlying API already had.⁴

Why are companies moving away from pay-per-call API pricing? Because it punishes efficient customers, doesn't correlate with actual value delivered, and creates unpredictable bills that finance teams resist approving.¹

Does extensible software eliminate integration costs? It removes the per-call toll, but it does not remove the need for real security controls. Authentication, audit logging, and access scoping still matter, arguably more, once an agent has direct write access.⁴³

How big is the API and SaaS cost problem this is meant to solve? A typical 200-person company's rented SaaS stack runs about $35,000 a month, or roughly $422,000 a year, and that figure only climbs as headcount and API usage grow.