OpenAI introduces Runme, which uses Codex to document repetitive work

Repeating the same cluster setup, the same evaluation runs

The engineer started their career on OpenAI's cloud infrastructure team, building Kubernetes clusters. Spending a week wrestling with private links, quotas, and Terraform to get one batch of clusters ready only meant the next batch was already waiting. Later, moving to the API team, they took on the job of running evaluations for new models — solving grader and PyTorch configuration issues, only to have to start the next model's evaluation from scratch the moment the previous one shipped. Most of the judgment calls and context built up through that repetition ended up scattered across terminal history, Slack messages, runbooks, and dashboards — and eventually just disappeared.

Runme: the notebook app Codex works in

The Runme project is open-source, published in the github.com/runmedev/web repository. Like Jupyter or Colab, it supports markdown, code cells, and HTML, so instructions, commands, results, tables, and charts can all live in a single document. An engineer writes a short goal in a notebook cell, and Codex treats that cell as its target — carrying out the work and continuously updating the notebook as it progresses. The engineer can watch progress from a phone and step in only when something gets stuck — for instance, when provisioning a dev environment hits a quota limit, they might suggest reusing an existing environment instead.

Once the work is done, the finished notebook still holds the paths that were tried, including the dead ends. Before wrapping up, the engineer works with Codex to record why a particular approach was chosen and what should be done differently next time — capturing decisions that would otherwise vanish inside a chat window. As the engineer put it: "I'm still the one who decides whether the plan is ready."

Notebooks save directly to Google Drive, and each one generates a companion markdown index file named *.index.md. Because Google Drive indexes these files, the next time Codex runs, it can search past notebooks for examples, operational context, or prior results through this index.

Connecting directly in the browser via WebMCP

The agent communicates with Runme through the WebMCP specification. When the Runme application loads, code that registers browser-side tools runs and exposes functions that Codex can use directly in the browser. Runme operates as a client-side app served as a static website with no backend — opening a traditional MCP endpoint would have required standing up a separate server and changing how notebook data is handled. WebMCP, by contrast, opens up these functions right inside the browser without that added infrastructure.

The author noted that while cloud computing and Kubernetes were supposed to make deployment and operations easier, they instead spawned a sprawling landscape of tools — pointing to CNCF's landscape map as an example. Solving one problem, they observed, tends to create a new problem: choosing, learning, and operating the tool meant to solve it.

How to try it

Runme's code is open source, so anyone can download the repository and run it directly.

1. Download the github.com/runmedev/web repository and run the application to open the notebook interface.
2. Create a new notebook and write a short goal for the task in a code cell — something like "test the new model using this evaluation system."
3. Ask Codex to take that cell as its target and start working. Codex reads the notebook, carries out the task, and continuously updates the cell's contents.
4. Once a plan is drawn up, review it and revise as needed. This is the stage where decisions get made — which evaluation system to use, whether to build new infrastructure, or whether existing resources will do.
5. When the work wraps up, record why that approach was chosen and what should change next time, right in the notebook. The finished notebook then saves to Google Drive.

Codex itself still requires a ChatGPT login or an API key to use, but Runme opens up, as open-source code, the browser-side workspace that Codex plugs into. What you can try right now isn't limited to building model evaluation pipelines — it also covers turning routine deployment checks or infrastructure provisioning into notebooks that teammates can reference directly from Google Drive.

Category	Old approach	Codex + Runme
Documentation	Scattered across terminal logs and Slack	Goals, process, and results unified in one notebook
Reuse	New automation script written each time	Past notebooks searchable via *.index.md
Sharing	Locked away in personal chat history	Shared with teammates via Google Drive

Editor's take

What makes this piece interesting isn't OpenAI showing off Codex — it's OpenAI showing, through an internal case, how Codex actually gets used day to day. If the Codex CLI we covered on August 23 was an agent that ran commands for you in the terminal, Runme plays the role of a container that documents that execution process itself. The number of tools hasn't grown; what's changed is how the traces those tools leave behind get captured.

Try applying this kind of notebook-based workflow in practice, and you keep hitting the same wall: automation scripts get written quickly, but nobody writes down why that particular approach was chosen. Even a team using a different agent instead of Codex could adopt the same habit — writing the task goal into a single cell and keeping results and decisions in the same document. That pays off especially in work where people rotate frequently, like onboarding new engineers or running routine deployment checks.

WebMCP is still an unfamiliar name, but the fact that OpenAI recently ran a hackathon with prize money behind it suggests the company is pushing fairly hard on the idea of opening up tools directly in the browser. It seems likely that a few more client-side agent tools along the lines of Runme will show up in the coming weeks, and whether they support WebMCP could end up being the line that separates agents you can plug in without server infrastructure from those you can't.