Cloudflare has removed a major barrier to building multi-agent systems: agents written in Python can now call methods on agents written in JavaScript and vice versa, with no protocol definitions, no serialization code, and no human-written contracts needed. The company announced the cross-language RPC (remote procedure call) capability on August 3 as part of its Agents Week, expanding a feature that previously only worked within JavaScript.

What Problem Does This Solve for AI Agent Teams?

When companies build AI agent systems, they often split services by programming language to reuse specialized libraries. A Python team might need Pygments for syntax highlighting, while a JavaScript team relies on a frontend framework. Traditionally, this meant building an HTTP API or protobuf service around the library and maintaining that contract forever. With Workers RPC now spanning Python and JavaScript, the method signature itself becomes the interface, and the runtime handles the translation automatically.

This matters especially for agent-generated systems, where different AI models favor different programming languages and toolchains for different tasks. A platform that lets those services call each other without a human-written contract removes a whole class of integration work from agent workflows.

How Does the Type Translation Actually Work?

The technical foundation rests on two layers. Pyodide, the CPython-to-WebAssembly interpreter that powers Python Workers, already includes a foreign function interface that maps basic types: integers and floats become JavaScript numbers, booleans become booleans, dictionaries become objects, and lists become arrays. Where direct translation is impossible, Pyodide creates a proxy object that forwards attribute access and method calls across the boundary, which is how passing a Python function as a JavaScript callback works.

The second layer is a thin conversion package called workers-runtime-sdk, which handles Cloudflare's own Web API objects like Request, Response, Blob, and File. Without it, Pyodide treats those as opaque JavaScript proxies. With it, they become idiomatic Python objects that Python developers expect to use.

The mapping also handles language-specific conventions. JavaScript passes object arguments, while Python passes keyword arguments. Cloudflare picked the mapping so neither side writes adapter code. A JavaScript method like get(key, { type: "text" }) can be called from Python as get("myKey", type="text").

What Can Cross the Language Boundary?

More than just plain numbers and strings. Structured-cloneable values convert to the appropriate native type on the other side. A JavaScript Date becomes a Python datetime. You can pass functions into a Python Worker and call them back, which makes cross-language callbacks and streams work without any glue code.

Here's what developers can now pass between Python and JavaScript Workers:

• Basic Types: Numbers, strings, booleans, and null values translate directly between languages with no conversion overhead.
• Complex Objects: Dictionaries, lists, dates, and Cloudflare Web API objects like Request and Response become idiomatic types on the receiving side.
• Functions and Callbacks: Python functions can be passed as JavaScript callbacks and vice versa, enabling streams and event handlers across the boundary.
• Proxy Objects: When direct translation is impossible, Pyodide creates proxy objects that forward method calls and attribute access transparently.

What Are the Real-World Performance Implications?

RPC between Workers typically does not cross a network. The other Worker usually runs in the same thread as the caller, and Cloudflare claims near-zero overhead compared with in-process code. That is a different category from HTTP calls between services, which is why the "no schemas" pattern stays fast enough to be the default rather than an optimization.

However, the feature inherits real constraints. Python Workers run CPython compiled to WebAssembly through Pyodide, so performance-sensitive Python code is still bounded by the WASM interpreter. Pyodide's FFI proxy objects work, but deep object graphs crossing the boundary repeatedly will cost more than a native call.

How to Build Multi-Language Agent Services

Developers can now structure agent systems across language boundaries with minimal boilerplate. Here's what the workflow looks like:

• Service Binding Configuration: Define a Service binding in wrangler.jsonc to connect a TypeScript Worker to a Python Worker, with no protobuf files or code generation required.
• Method Calls Across Languages: A TypeScript Worker can call a method on a Python Worker as if it were a local module, passing arguments and receiving results with automatic type translation.
• Callback and Stream Handling: Pass functions between languages to enable callbacks, event handlers, and streaming data without writing adapter code on either side.
• Deployment Without Contracts: Deploy both Workers with uv run pywrangler deploy, and the runtime handles all type bridging automatically through the workers-runtime-sdk package.

The clearest framing is in Cloudflare's own announcement: one coding agent can write a Python Worker and another can write a JavaScript Worker, and the runtime handles the rest. The type-bridging is the real product, because it removes the interface contract from the critical path entirely.

What Else Did Cloudflare Announce for Agent Builders?

The same week, Cloudflare also shipped inbound TCP and gRPC support for Workers, which pairs naturally with cross-language RPC. RPC covers internal service-to-service calls, gRPC covers client-facing APIs, and both now work with Python. The agent angle connects to the multi-agent orchestration space, where teams are building heterogeneous agent fleets that need cheap, typed communication between components.

Cloudflare also launched @cloudflare/computer, an open-source agent runtime where an SQLite-backed workspace gives every agent a shared filesystem and lets the model pick between fast isolates and full Linux containers per task. The bet is that containers are needed for under 10 percent of agent work.

These announcements reflect a broader shift toward polyglot service boundaries as the norm rather than the exception. With open-weights models like Qwen 3.8 Max promising the first open-weights Max-class release, mixed ecosystems where different agents use different languages and toolchains are becoming standard practice.