MCPWorks Functions: Developer Preview is Open

Today we're opening MCPWorks Functions in Developer Preview.

Functions is the first product on the MCPWorks platform. It lets AI assistants create, manage, and execute custom functions directly over HTTPS using the Model Context Protocol. No local proxy. No Docker setup. No git repos to clone. Your AI connects to your namespace endpoints and starts working.

Developer Preview is free at the Builder tier for up to 90 days. No credit card required to start. No obligation to continue. If you sign up and decide it's not for you, cancel any time. When the preview period ends, we'll give 14 days notice before accounts are downgraded to the free tier.

We're opening this up now because we want real feedback from real engineers building real things.

The problem we keep hearing about

There are three infrastructure problems that don't get enough attention.

Token costs are artificially low right now

Inference pricing in 2026 is heavily subsidized by investor capital. The major providers are burning cash to capture market share, and everyone building on top of those APIs is benefiting from pricing that does not reflect the true cost of running the hardware.

That won't last.

When the correction comes, and it will, token prices will spike. Hardware improvements will bring costs down over time, but they won't close the gap between today's subsidized rates and what it actually costs to run inference at scale. The companies that survive that correction will be the ones that figured out how to use fewer tokens to get the same work done.

MCP packages are bloated by design

Developers who build MCP servers are enthusiastic people. They ship feature-rich suites with dozens or hundreds of tools because they want their servers to be comprehensive. That's a good instinct for traditional software, but it's a terrible pattern for AI assistants.

Every tool connected to an AI assistant has its full schema loaded into the context window. A single MCP server with 15 tools might consume 10,000 to 15,000 tokens of schema definitions. Connect five or ten servers and you're looking at 150,000+ tokens of overhead before the AI does a single useful thing.

That overhead costs money on every interaction. And most of those tool definitions are never used in any given conversation. Your AI is paying to know about tools it will never call.

Managing MCP across agent fleets is painful

If you're running AI agents at scale, you know this problem. You have a cluster of 8, 16, or 50 agentic systems. Each one has its own MCP configuration. When you need to update a function or add a new capability, you're pushing changes across every machine. Git pulls, config updates, service restarts, and hoping nothing breaks in the process.

And when something does break? You're debugging across a fleet of machines that may or may not have picked up the latest changes.

What MCPWorks Functions actually does

Code-mode execution

This is the core of what we built, and it deserves a proper explanation.

Traditional MCP works like this: your AI assistant loads the complete schema for every tool it has access to. All the parameter definitions, all the type information, all the usage descriptions. Everything goes into the context window upfront, whether the AI needs it or not.

Code-mode execution flips this model. Instead of loading full tool schemas, the AI receives a lightweight list of available function names and one-line descriptions. When it needs to accomplish a task, it writes compact Python or TypeScript code that calls those functions. That code executes in a secure sandbox on MCPWorks infrastructure.

The critical part: intermediate data stays inside the sandbox. If your AI is processing 50 customer orders, those 50 order objects never enter the AI's context window. The code runs, processes the data, and only the final result comes back to the AI.

Anthropic's own research on this pattern (published January 2026) measured the impact:

78% fewer tokens per operation compared to traditional MCP
98.7% reduction in tool definition overhead
~70% reduction in total cost per interaction

These aren't theoretical numbers. They come from comparing traditional MCP tool loading against the code-mode execution pattern across real workloads.

Code-mode also has a privacy benefit that matters for regulated industries. Because intermediate data stays in the sandbox and never enters the AI's context, you get architectural data minimization. Sensitive records, financial data, and PII stay in the execution environment. The AI only sees the processed results you choose to return. That's compliance by design, not compliance by policy.

Namespace-based management

Every MCPWorks account gets dedicated namespace endpoints:

Create endpoint for building and managing functions
Run endpoint for executing them

Your AI assistant connects to these endpoints over HTTPS using standard MCP transport. It can create new functions, update existing ones, list what's available, and execute anything in the namespace.

This is where the fleet management problem gets solved. Functions live on MCPWorks infrastructure, not on individual machines. When an AI with Create access updates a function, that change is immediately available to every system connected to the Run endpoint. No git pushes. No config syncs. No rolling restarts.

Self-healing agent infrastructure

Here's where it gets interesting for teams running agent fleets.

Say you have a primary AI orchestrator (Claude, Codex, whatever you prefer) managing a swarm of 16 agentic systems powered by a different model. The orchestrator is writing and refining functions on MCPWorks. Those functions are automatically available to the entire swarm through the shared Run endpoint.

If the swarm reports problems with a function, or if the orchestrator observes errors in execution logs, it can update or roll back the function immediately. The fix propagates to every agent in the cluster without touching a single machine.

This creates a feedback loop: deploy, observe, fix, redeploy. All through the same MCP interface. All without human intervention if that's how you want to run it. Your AI infrastructure becomes self-healing because the same AI that's consuming the functions can also maintain them.

Works with any AI

MCPWorks is AI-agnostic infrastructure. We work with Claude, GitHub Copilot, Codex, Kimi, Gemini, or any client that speaks MCP. We don't supply AI tokens. We don't host models. We don't care which reasoning engine you prefer.

You bring your AI. We host the functions.

What's coming next

Functions is the first product on the platform. The Code Execution Sandbox is the foundation that everything else builds on. We have additional backends and capabilities planned, all accessible through the same namespace interface and all benefiting from code-mode execution.

We'll share more as we get closer to shipping those pieces. For now, we want to get Functions right.

Developer Preview details

Duration: Up to 90 days
Access: Full Builder tier features at no cost
Obligation: None. Cancel any time during the preview
After preview: 14 days notice before accounts downgrade to free tier
What we ask: Use it. Break it. Tell us what works and what doesn't

If you're an engineering manager or CTO evaluating AI infrastructure, or if you're a developer building with AI agents and tired of managing MCP servers across machines, we'd like to hear from you.