Forge

Forge is an open-source, browser-based IDE where humans and AI agents can work on the same project.

Comment

Forge

An agent-native web IDE for humans and AI agents

Inspiration

AI coding agents can generate impressive amounts of code, but generating code is only one part of software development.

A real development workflow also involves creating projects, managing files, installing dependencies, running applications, reading console output, debugging errors, rebuilding, and eventually deploying the result.

Most AI coding experiences handle these tasks through a chat interface, while the actual development environment remains separate.

Forge asks a different question: what if the development environment itself could be used by an AI agent?

Forge is a browser-based IDE where humans and AI agents can work on the same project. Instead of asking an agent to generate code and then manually moving that code into an IDE, Forge exposes its development capabilities directly through WebMCP.

The agent can operate the IDE itself.

Why WebMCP?

Forge is a particularly strong fit for WebMCP because its core functionality is already organized around meaningful actions that an agent needs to perform.

An IDE is not just a page to read. It is an environment to operate.

Before WebMCP, an agent interacting with a browser-based IDE would need to rely on indirect mechanisms such as simulated clicks, keyboard input, or copying and pasting code.

With WebMCP, Forge can expose its capabilities as structured, semantic tools.

The agent can discover what Forge can do and directly invoke those capabilities.

This transforms the IDE from a human-only interface into an agent-accessible development environment.

What agents can do in Forge

Forge exposes meaningful development operations through WebMCP, including:

  • Create and manage projects
  • List project files
  • Read files
  • Write and modify files
  • Run projects
  • Inspect console output
  • Build projects
  • Deploy projects

These tools are connected directly to Forge's underlying application logic.

The WebMCP layer is therefore not a separate demonstration layer. The agent and the human interface operate on the same project and the same underlying state.

For example, an agent can be asked to:

"Create a React landing page for a fictional company."

It can then:

  1. Create the project.
  2. Create and modify the required files.
  3. Run the development server.
  4. Inspect the result.
  5. Check the console for errors.
  6. Modify the code when necessary.
  7. Build the project.
  8. Deploy it.

The agent is not merely generating a code snippet. It is operating the development environment.

Human + Agent collaboration

Forge is designed around collaboration rather than replacement.

The human developer remains inside the IDE and can see the project, preview the application, inspect the code, and make manual changes at any time.

The agent can perform repetitive or complex development operations through WebMCP while the human remains in control.

A developer can ask an agent to create a project, modify multiple files, run it, inspect an error, fix the problem, and build the result.

The developer can then review the changes, edit the code themselves, and ask the agent to continue.

Both human and agent can work on the same project without leaving the development environment.

This is the experience that WebMCP makes possible.

What was difficult before?

Without WebMCP, an AI assistant could generate the code for a project, but the developer would still need to transfer that code into the development environment and manually perform many of the surrounding operations.

The workflow becomes:

Ask AI → Copy code → Open IDE → Create files → Install dependencies → Run → Find errors → Go back to AI → Copy fixes → Repeat

Forge changes this interaction into:

Ask agent → Agent operates Forge → Review → Iterate

The important difference is not simply that AI can write code.

It is that the agent can use the tools of the development environment itself.

Built for the browser

Forge runs directly in the browser using WebContainers, providing a real development environment without requiring a local installation.

The editor is powered by Monaco Editor, giving developers a familiar coding experience while keeping the entire workflow inside the browser.

Forge is built with:

  • React
  • TypeScript
  • Vite
  • Monaco Editor
  • WebContainers
  • WebMCP
  • Tailwind CSS

WebMCP implementation

Forge registers its capabilities using the WebMCP API through document.modelContext.registerTool().

Each tool has a clear name, description, structured input schema, and execution function.

The tools call Forge's actual application logic rather than simulating interaction with the UI.

This architecture allows both the human interface and AI agents to work with the same underlying functionality.

The result is a genuine WebMCP integration rather than a chatbot placed on top of an existing application.

Execution and agent-native design

Forge was designed around the idea that WebMCP tools should represent meaningful operations, not low-level interface actions.

Instead of exposing tools such as "click button" or "type text", Forge exposes higher-level development operations such as create_project, read_file, write_file, run_project, get_console, build_project, and deploy_project.

This makes the interface understandable to an agent while keeping the application usable for humans.

The result is an IDE that has two interfaces:

A visual interface for humans. A structured tool interface for agents.

Both operate on the same environment.

Potential impact

Forge explores a future where web applications are not only designed for people, but are also designed to be used by AI agents.

For developers, this could reduce the friction between AI-generated code and a working application.

For AI agents, it provides a structured environment where they can move beyond generating text and actually perform meaningful software development tasks.

The same principle could extend beyond IDEs to other professional web applications: design tools, data platforms, project management systems, scientific software, and more.

Forge is therefore an experiment in a broader idea:

What happens when the tools we use every day become directly accessible to AI agents?

Creativity & ambition

Forge is not simply an online code editor with AI assistance.

It explores the idea of an agent-native IDE: an environment where AI agents are first-class users of the application rather than external assistants sitting beside it.

WebMCP provides the bridge between the agent and the application.

The goal is not to make AI better at pretending to be a developer.

The goal is to give AI agents the tools they need to actually participate in the development process.

Open source

Forge is open source and designed to be transparent and inspectable.

The project demonstrates how a complex browser application can expose useful capabilities to AI agents through an open web standard.

Built for the WebMCP Challenge

Forge was created for the WebMCP Challenge to explore the future of the open web, where humans and AI agents can interact, collaborate, and create together.

The central idea is simple:

The future of agentic software may not be an AI sitting beside an application — it may be an AI working inside it.

Forge — The IDE that agents can use.

Built With

Share this project:

Updates

Submission history