Bridging DeepSeek's Web Interface into Harness: A Real-World Test of Free Compute for Local Code Editing

A Bold Idea: Put the Web Model to Work Directly

Paid model APIs are reliable, but for individual developers, the daily usage costs can add up fast. Bilibili creator Dapao took a different approach — DeepSeek's web interface is free, so could it be wired directly into a local development environment to read files and edit code, bypassing the API entirely?

His answer is a bridging setup: a plugin installed in Harness, plus a Chrome extension, passing data between both ends in a specific format. This lets Harness treat the web chat window as a model API, while the underlying compute remains completely free.

To put it simply, Harness is the runtime environment that works alongside AI models — it typically requires a model API to function. The value of this plugin is that it removes the assumption that you must pay for API access. When "Hello" appears on screen and the web output syncs in real time, it means the bridge is live — you can watch the model's thinking alongside the web's live feedback, and jump directly to the corresponding task conversation through an embedded window.

Harness is a category of runtime frameworks that give AI models tool-calling capabilities (also called Agent frameworks or orchestration layers). It breaks down user instructions into concrete operations and invokes local tools like file read/write, code execution, and terminal commands. Similar tools include Continue, Cursor, and Cline — all VS Code plugins. The core value of these frameworks is that they let models do more than just chat; they can actually operate the file system and complete multi-step tasks. Normally, Harness must communicate with the model through an official API — the API key serves as both authentication and billing. The innovation here is that the Chrome extension simulates a "fake API endpoint," making Harness think it's talking to a normal model interface, when in reality requests are being forwarded to the already-logged-in web chat window in the browser.

Is the Free Web Version Actually Good Enough? A Counterintuitive Test

What genuinely surprised the author was the web model's real-world performance. He chose a classic benchmark: generating an animation of a teapot riding a bicycle.

The results were dramatic:

• DeepSeek V4.1 Flash via API (low inference setting): Took 9 minutes 2 seconds. Background elements, pedals, and leg sync rotation all largely passed.
• API high inference setting: Actually failed — the first generation wouldn't run, and after a second attempt the assets were flying around the screen chaotically.
• Free web version: Took only 5 minutes 56 seconds, with overall quality close to the API's low inference setting.

This comparison might tempt you to conclude that the free web version beats the paid API, but the author kept a clear head. He pointed out a flaw in the test: the web model only needed to send back one complete block of code from the cloud to produce the animation — that doesn't prove it can modify local files. Generating a snippet of code and actually editing a real project are two completely different things.

From "Generate" to "Modify": The Real Difficulty Threshold

To test genuine capability, the author asked the web model to make a second round of edits to the locally generated animation file. The first two attempts failed — once blocked by a context window that was too long, once by tool-calling compatibility issues.

But even the failures showed promise: the model had already started calling tools in sequence. It read the actual file, got the result, and then decided how to modify it; Harness returned the execution result to the web, and the web proposed the next operation. The "read → decide → execute → feedback" loop was running — just not reliably yet.

The author summarized the remaining work as fine-tuning several transmission details:

• Context too long: Summarize history in segments, keep recent results, and if necessary start a new web conversation carrying over the progress.
• Tool calls: Check whether they meet requirements before handing off to Harness for execution.
• Wrong output format: Return the specific error to the model for correction; if it's still wrong, stop — never guess and execute anyway.

These seemingly minor details directly determine whether the model can keep working continuously.

"Tool Use" (also called Function Calling) refers to the model not just outputting text in its responses, but outputting structured instructions in a predefined format that request an external program to execute an operation and return the result. For example, the model might output "read lines 30–80 of animation.js," which Harness actually executes before returning the content to the model. This mechanism is the foundation of Agent capabilities, but it demands extremely consistent output formatting — even an extra newline or missing bracket can break the parser. Web model output isn't specifically optimized for tool calling, so early versions frequently produced format errors, requiring additional validation and error-correction logic as a safety net.

After 20+ Iterations: Local Modification Finally Works End-to-End

After more than 20 iterations, the local modification task finally ran through completely. The author used the animation originally generated from a simple prompt as a starting point and let the model continue upgrading it on its own.

The results showed visible progress: the legs gained skeletal structure, pedaling speed became adjustable, and the background could switch between times of day. The model genuinely completed the full pipeline — reading the original file, writing the modifications, calling tools to check, and finally opening the finished result to confirm the changes actually took effect.

At this point, "bridging the web interface into Harness" had real, practical value. Following the same approach, the author also successfully connected the Doubao web interface.

Getting Connected Is Just the Starting Point: How Far Is There Still to Go?

The author is candid: getting it connected is only step one. How large a project the web model can actually handle, and how to make the most of each day's free quota — these questions still need real-world validation.

The project is now open source. Install the plugin into Harness and run the pairing tool following the instructions, with detailed steps and troubleshooting in the project documentation. Note that the current stable release supports DeepSeek first; support for other web interfaces is still being validated.

The author's next goal is to build a more complete project from scratch using only the web model, pushing its capability to the limit. For developers who want to cut API costs and don't mind tinkering, this setup offers a compelling approach worth trying — even if it isn't yet a "stable production tool," it has demonstrated that free web compute can meaningfully integrate into a local development workflow.