Code Mode is an approach to AI tool execution where MCP servers are presented as code APIs rather than direct tool calls. Instead of loading all tool definitions upfront and passing large datasets through context, Code Mode enables on-demand tool discovery, processes data in sandboxes, enables parallel execution, and dramatically reduces token usage.

When should I use pctx instead of traditional MCP?

Use pctx when you need better performance, lower costs, or are working with complex multi-tool workflows. pctx reduces token usage by 98.7% (from 150K to 2K tokens), enables parallel execution instead of sequential tool calls, and provides sandbox security. It's especially valuable in production environments where token costs and context limits are concerns.

How does pctx compare to Anthropic and Cloudflare's Code Mode?

pctx implements the same Code Mode principles pioneered by Anthropic and Cloudflare: presenting MCP servers as code APIs rather than direct tool calls. The key difference is that pctx is open-source (MIT license), self-hostable, and works with any LLM (Claude, GPT, Gemini, etc.), giving you full control without vendor lock-in.

Is pctx production-ready and secure?

Yes. pctx is production-ready with comprehensive security features including isolated sandbox execution, secure credential management, resource limits, and full audit logging. It's actively maintained, has horizontal scaling support, and includes monitoring integration (Prometheus, OpenTelemetry). The sandbox environment ensures code execution cannot access your host system without explicit permission.

Can I use pctx with my existing LLM and tools?

Absolutely. pctx is designed to work with any LLM (Claude, GPT-4, Gemini, local models, etc.) and integrates with all existing MCP servers. You can connect internal tools, third-party APIs, or custom services. The framework is LLM-agnostic and follows the standard Model Context Protocol, ensuring broad compatibility.

What's the performance impact of using pctx?

pctx dramatically improves performance. You'll see a 98.7% reduction in token usage (150K → 2K tokens for complex workflows), 5-10x faster execution through parallel processing, and corresponding cost savings. For example, a complex request that costs $0.45 with traditional MCP costs only $0.006 with pctx using Claude Sonnet pricing.

How difficult is it to migrate from traditional MCP or direct API calls?

Migration is straightforward. For traditional MCP: install pctx, configure your existing MCP servers, and update prompts to generate code instead of tool calls. For direct APIs: wrap them as MCP servers (many popular services already have MCP implementations) or create simple adapters. Most teams complete migration in a few hours with immediate performance benefits.

Do I need cloud infrastructure to use pctx?

No. pctx runs locally on your development machine, in Docker containers, or on any cloud platform (AWS, GCP, Azure, Vercel, Railway, etc.). There's no cloud dependency or required subscription. You have full control over where and how pctx runs, making it ideal for both local development and production deployments.

What are the main advantages over building custom tool integrations?

pctx provides a unified interface for all your tools (no need to build custom integrations for each), automatic type safety through code generation, built-in sandbox security, parallel execution capabilities, and dramatic token reduction. Instead of managing multiple API clients, authentication systems, and error handling for each tool, you get a single consistent framework with production-ready features.

Can pctx handle enterprise-scale deployments?

Yes. pctx supports horizontal scaling across multiple instances, includes load balancing, rate limiting, queue management for high throughput, and integrates with enterprise monitoring systems. It's designed for production use with features like health check endpoints, comprehensive logging, and support for secret management systems (Vault, AWS Secrets Manager, etc.).

What's the relationship between pctx and the Model Context Protocol?

pctx is built on top of MCP and enhances it with Code Mode execution. While MCP defines how tools communicate with AI systems, pctx optimizes this communication by presenting MCP servers as code APIs, reducing token usage by 98.7%, and enabling sandbox execution. Think of pctx as the production-ready Code Mode framework for MCP.

pctx: Unified Code Mode for MCP | Open Source Release

Name: pctx - Port of Context
Rating: 5 (1 reviews)
Author: Port of Context

Launching the first open-source framework that turns any MCP server into a Code Mode environment. Built for AI engineers who need efficient tools and MCPs.

Code Mode fundamentally changes how AI agents interact with external tools. Instead of serializing tool definitions into context windows and waiting for sequential tool calls, Code Mode presents MCP servers as deterministic APIs that agents can orchestrate through generated code.

Port of Context released pctx, the first open-source framework that provides unified Code Mode execution across any upstream MCP server. This release solves the core architectural challenge: how do you transform arbitrary MCP servers into a cohesive, type-safe execution environment that agents can reason about programmatically?

The Context Window Problem

Traditional MCP implementations suffer from a fundamental constraint: every tool must be serialized into the agent's context window before execution.

Consider a realistic workflow:

50 available tools across GitHub, Stripe, and internal APIs
Each tool: ~200 tokens for definition + examples
Context cost: 10,000 tokens before any actual work
Sequential execution: request → wait → parse → request → wait
No parallelization, no composition, no state management

For a complex request requiring 15 tool calls:

Traditional MCP: ~150,000 tokens | 47 seconds | $0.45
Code Mode: ~2,000 tokens | 8 seconds | $0.006

Architecture: Unified MCP Proxy

pctx acts as a unified proxy layer between agents and upstream MCP servers. Instead of exposing raw tool definitions, pctx generates a type-safe API surface that agents can call through generated code.

System Design

Code Mode Request Flow

Compare this to traditional tool calling, which would require 5 sequential round-trips with full context overhead at each step.

Implementation Deep Dive

1. Dynamic Type Generation

When pctx connects to an upstream MCP server, it introspects the tool definitions and generates TypeScript type signatures at runtime:

// MCP tool definition received from server
{
  "name": "github_create_issue",
  "description": "Create a GitHub issue",
  "inputSchema": {
    "type": "object",
    "properties": {
      "repo": { "type": "string" },
      "title": { "type": "string" },
      "body": { "type": "string" }
    },
    "required": ["repo", "title"]
  }
}

// pctx generates this API surface for agents
async function github_create_issue({
  repo: string;
  title: string;
  body?: string;
}): Promise<GithubIssue>

Agents receive only the generated function signatures in their context—not the full JSON schemas. This reduces the per-tool context from ~200 tokens to ~15 tokens.

2. Sandbox Execution Model

The execution environment uses a custom deno runtime with strict isolation:

// validated at before execution with an embedded typescript compiler

execute("llm-code", { 'github', 'create_issue', 'stripe', 'send_payment' } ),

// agent gets typescript compiler errors if types are used incorrectly

Real-World Example: Customer Support Automation

Here's how an agent uses pctx to handle a complex customer support workflow:

Agent prompt: "User @sarah_dev reported billing issues. Investigate and resolve."

Generated Code:

// 1. Parallel data gathering
const [githubUser, stripeCustomer, recentIssues] = await Promise.all([
  github_get_user("sarah_dev"),
  stripe_search_customers({ email: "sarah@example.com" }),
  github_list_issues({ repo: "acme/billing", label: "bug", state: "open" })
]);

// 2. Cross-reference and analyze
const userIssues = recentIssues.filter(issue =>
  issue.author === githubUser.id
);

if (userIssues.length > 0) {
  console.log(`Found ${userIssues.length} related issues`);

  // 3. Check billing status
  const invoices = await stripe_list_invoices({
    customer: stripeCustomer.id,
    status: "open"
  });

  if (invoices.length > 0) {
    // 4. Automated resolution
    await stripe_void_invoice(invoices[0].id);
    await github_create_comment({
      issue: userIssues[0].number,
      body: "Invoice voided. Billing issue resolved."
    });

    console.log("Issue resolved automatically");
  }
}

Execution: 3.2 seconds, single round-trip, 156 tokens

Traditional MCP equivalent: 8 tool calls, 1+ mins, thousands of tokens

Security Model

pctx enforces defense-in-depth security:

Key security guarantees for local development

No arbitrary code execution: Only validated tool calls allowed
Network isolation: Tools define all network access explicitly
Audit trail: Every tool call logged with input/output/duration

Installation & Quickstart

# Install pctx
npm install -g @portofcontext/pctx

# Connect to existing MCP servers
pctx mcp add github --config ~/.config/mcp/github.json
pctx mcp add stripe --config ~/.config/mcp/stripe.json

# Start the unified server
pctx mcp start

# Your agent now sees a single Code Mode API
# instead of multiple MCP servers

About Port of Context: Port of Context unlocks production agentic AI by managing secure and token efficient connections to data and APIs.

Follow pctx

GitHub: github.com/portofcontext

Announcing pctx: A Local & Open Source Code Mode Framework