QuantumJS + WebMCP

QuantumJS brings quantum computing to the web in the agentic era, transforming how we learn and experiment with circuits through WebMCP.

Comment

Inspiration

Quantum computing has a strange accessibility problem, the field is making steady progress, but much of its tooling remains disconnected from both the AI and agentic era and the web-centered ecosystem where modern developers learn, experiment, and build. While this is a bleeding edge research field, much of the existing ecosystem paradoxically feels like it belongs to a decade ago.

QuantumJS was created to address that gap. It brings quantum circuit authoring, simulation, visualization, documentation, and an interactive IDE to the JavaScript/TypeScript/web ecosystem. Its circuit DSL is expressive enough for serious experimentation while remaining natural to web developers, and its IDE makes quantum programs something you can actually see, execute, and explore.

WebMCP suggested a much bigger possibility.

If QuantumJS can expose its capabilities directly to AI agents, an agent no longer has to guess how to navigate a quantum IDE. It can discover the application's capabilities and use them as structured tools: explore examples, work with quantum circuits, execute simulations, inspect results, and consult the project's documentation.

This turns QuantumJS from an IDE that a person operates into a shared workspace where humans and agents can reason about quantum programs together.

That is the experience we wanted to explore with this project.

What it does

QuantumJS is an open-source quantum computing ecosystem for the JavaScript/TypeScript/web platform.

It provides:

  • A fluent quantum circuit DSL that compiles to OpenQASM
  • An interactive browser-based quantum IDE
  • Quantum circuit visualization
  • Simulation and measurement analysis
  • A collection of real quantum circuit examples, including circuits based on published research
  • Documentation and learning material
  • Interactive stepped simulation that lets users observe how a circuit evolves at different points in its execution

For this challenge, we added WebMCP as a new interaction layer across the QuantumJS web application.

An agent can now interact with QuantumJS through structured capabilities exposed by the application rather than having to infer how to operate its interface. This allows a human to ask an agent to investigate a circuit, explore available examples, execute quantum computations, inspect the resulting behavior, and use the application's documentation as part of the same workflow.

The important change is that the agent is not merely looking at QuantumJS. It can work with QuantumJS.

A human can therefore remain in the loop while the agent handles exploration, repetitive experimentation, and interpretation. The result is a collaborative workflow that would be extremely cumbersome if an agent had to navigate the application's UI through clicks and guesses.

How we built it

QuantumJS is built around a JavaScript/TypeScript-native quantum programming model and a browser-based IDE.

For the WebMCP challenge, we extended the existing application with WebMCP tool definitions that expose meaningful QuantumJS operations to compatible agents. These tools are registered through the WebMCP document.modelContext API and provide structured descriptions and input schemas rather than requiring an agent to infer interactions from the visual interface.

The WebMCP layer sits on top of the existing QuantumJS functionality rather than replacing it. The same application remains fully usable by humans, while agents gain a first-class way to discover and invoke its capabilities.

This was particularly interesting because QuantumJS already combines several traditionally separate activities—writing circuits, visualizing them, simulating them, inspecting measurements, and reading documentation—inside a single web environment. WebMCP lets an agent move between those capabilities as part of one workflow.

The project is open source, and the WebMCP implementation is visible in the repository's commit history so that the new work can be distinguished from the pre-existing QuantumJS codebase.

Challenges we ran into

The biggest challenge was deciding what should actually be exposed as an agent tool.

It is easy to expose a collection of low-level functions and call that WebMCP support. It is much harder to decide what an agent genuinely needs in order to accomplish useful tasks.

Quantum computing makes this particularly interesting because the underlying operations can be highly technical. A useful agent interface needs to expose capabilities at a meaningful level while preserving the expressive power of QuantumJS.

Another challenge was integrating WebMCP without compromising the existing human experience. QuantumJS is first and foremost a browser-based development environment, so the agent interface needed to complement the IDE rather than turn it into an agent-only application.

Finally, we had to think about what it means for an agent to work with a computational environment rather than simply retrieve information from it. QuantumJS doesn't just contain static documentation. It can execute quantum circuits and produce computational results. Making those capabilities available to an agent creates a substantially richer interaction model.

Accomplishments that we're proud of

We are particularly proud that WebMCP is not a superficial addition to QuantumJS.

The application already contains a complete environment for authoring, visualizing, and simulating quantum circuits, and we were able to make those capabilities accessible to agents through the same web application.

This creates a workflow that feels fundamentally different from traditional web automation:

Human: "Explore the examples and find a circuit that demonstrates quantum interference."

Agent: discovers the available QuantumJS capabilities, explores the examples, runs relevant circuits, examines the results, and explains what it found.

The human can then take over, modify the circuit, ask a follow-up question, or direct the agent toward another experiment.

We are also proud to bring this interaction model to quantum computing specifically. Quantum software is a domain where experimentation is central to learning and research, making an agent that can actually execute and investigate programs much more useful than one that can merely read documentation.

Most importantly, we extended a pre-existing open-source project with a genuinely new capability during the challenge period. WebMCP is a new addition to QuantumJS, not something that existed in previous versions of the project.

What we learned

The biggest lesson was that making an application agent-compatible is not simply an API-design exercise.

A traditional API is usually designed around what the application can do. An agent interface has to additionally consider what an agent needs to understand in order to accomplish a task.

WebMCP makes this distinction particularly visible. Tool descriptions, schemas, and the granularity of exposed operations become part of the application's user experience for agents.

We also learned that computational applications may be especially interesting candidates for WebMCP. When an agent can not only retrieve information but also execute computations and inspect their results, the interaction becomes iterative:

discover → construct → execute → observe → reason → modify → execute again

That loop is a natural fit for quantum programming.

What's next for QuantumJS + WebMCP

WebMCP opens a much larger direction for QuantumJS.

We want to expand the agent interface so that agents can become increasingly capable collaborators inside the quantum development workflow: helping construct circuits, explaining algorithms, debugging unexpected measurements, comparing implementations, generating experiments, and guiding users through educational material.

Beyond that, the QuantumJS roadmap includes a WebGPU-native simulator, measurement-based quantum computing support, deeper agentic coding integration, and substantially more educational content.

Our long-term goal is to make quantum computing feel native to the web, not just by putting a quantum simulator in a browser, but by creating an ecosystem where humans, quantum programs, and AI agents can work together in the same computational environment.

WebMCP is an important step toward that future.

Built With

Share this project:

Updates

Submission history