Framer Harness 2 Runs Agent Code as the Model Writes It

Tell Framer's agent to "find every use of our old brand color and replace it" and it may have to look at thousands of nodes and change hundreds of properties. The old way was a long chain of small model calls, each one replaying the conversation so far. On Monday, Nov. 2, Framer said its new Framer Harness 2 had rebuilt that machinery.

Framer is a website builder with an AI agent that edits your design document directly. Harness 2 is not a new model. It's the layer that turns the model's output into real edits, and Framer's engineering post says the rebuild makes the agent "up to 33% cheaper, and 20% faster."

Framer's announcement on X, Nov. 2, 2026 (@framer)

View on X

Executing half a program

The first harness used a small command language for writes. The model emitted commands to create nodes and set properties, and you watched the page take shape. Repeated edits were the weak spot: Framer says changing one property across 100 frames could take 100 commands, and reading a value before writing it needed separate model calls.

Harness 2 lets the model write JavaScript instead, with loops, conditionals and direct reads of the document. The catch is that a long program takes a long time to generate before anything happens. So Framer parses the code as it streams in, groups complete statements into "cells," and sends them to a Web Worker that runs them in order. In the post's words: "We compile incoming code into executable cells and run them as they become available."

You see the first changes on the canvas before the model finishes. Framer also tells the agent to check its assumptions up front. If a required node is missing, an early return or a thrown error stops the rest of the stream, "avoid[ing] further output-token charges."

A stop that doesn't undo anything

Cancellation has a limit that the announcement states in one line: "Cancellation preserves edits already applied to the document." Cells that already ran stay run. The post doesn't describe a rollback, so a program that fails halfway leaves a half-edited page, and the agent gets an error message to try again from there.

Smaller write errors don't stop anything. According to the post, the harness applies valid properties, clamps out-of-range values (an opacity of -0.1 becomes 0), skips unsupported ones, and attaches warnings to the final result. The old INSERT and PATCH commands became tree.insert() and tree.patch(), and the Web Worker keeps an in-memory copy of the document so reads and writes are synchronous.

Two numbers for one thing

Here's where the post needs a careful read. Near the top it says the new architecture "uses 2x fewer tool steps and 39% fewer cached input tokens per message, on average." Near the end: "The result is 43% fewer tool steps and 39% fewer cached input tokens per message."

Those aren't the same claim. By our arithmetic, "2x fewer" means half the steps, a 50% cut, while 43% fewer means about 1.75 times fewer. The post doesn't say whether they cover different tasks, different periods or different definitions. The 39% token figure matches in both places.

The cost claim is thinner still. "Up to 33% cheaper" comes with no baseline, no task list and no model named, and "20% faster" applies to "long tasks" that the post doesn't define. It also says there was "no measured reduction in quality," without saying how quality was measured.

That's a change from Framer's own recent habits. Its July 21 post on making the agent cheaper showed one traced task going from 36 steps to 12, with cached replay cost falling from $1.969 to $0.548 and a note of "no regression on CanvasBench." Harness 2 gets percentages and a diagram labeled illustrative. Our reading: the direction is believable, since the July post already showed how much cost piles up from replayed context, but the Harness 2 numbers are a company's own claim until a table appears.

The paper Framer found afterward

The post ends with an admission that's easy to miss. Framer writes that it believed it was first, then found a paper, Executing as You Generate, by Zhensu Sun and colleagues, first posted on arXiv on April 1, 2026. The authors' EAGER system does the same core thing in Python: AST-based chunking, persistent state and stopping generation on runtime errors. Framer says it "plan[s] to adopt" one optimization from it, removing completed statements from the parse buffer.

The paper's abstract reports a latency cut of up to 37.3% on error-free runs across four benchmarks and seven models. That's a different setup from Framer's product, so the 20% and 37.3% aren't comparable. It does show the idea has independent testing behind it. It also sits oddly beside the post's earlier claim that the approach is a "novel" design for real-time feedback.

One program from outside

The other change is for people who drive Framer from their own tools. Framer says external agents like ChatGPT Desktop, Claude Code and Cursor used to make repeated requests through its servers. Now they get "the same tools as the in-app agent" and can submit one program over MCP that runs inside Framer.

The post doesn't list permission limits, rate limits or which models the in-app agent runs on. Those would tell you how safe it is to let an outside agent run a long program unattended.

Before you trust the percentage

If you use Framer's agent, the useful test is your own recurring job, such as a site-wide color or text swap. Run it before and after on a copy of a project and compare the steps, the time to first visible change and the usage on your plan. Then ask for something that should fail, like a node that doesn't exist, and check what the agent leaves behind. Framer's own diagram says the exact savings "depend on how far generation has progressed when cancellation takes effect." Your result will depend on the same thing.

Source: Framer

framer framer agent harness 2 mcp ai agents

AI

About the author

AI Briefing Daily Editorial. The editorial desk of AI Briefing Daily, an independent publication covering artificial intelligence. Every story is researched against primary sources, checked by hand and reviewed by a person before publication.