My take is that everyone should strive to burn as many tokens as they possibly can.
Of course, burning more tokens doesn't always mean more work got done. Figuring out how to burn tokens in productive & tasteful ways is the job in 2026. Interestingly, that is everyone's job now.
One agent is easy. You can stay in the loop while the work is happening. However, as you add more agents and run them parallely things start to break. Add agents for coding, research, testing and marketing, and you need to track what each one is doing, what changed, which task needs a decision and what has finished. A lot of mental gymnastics. This gets even more complex if you are trying to work on multiple projects using multiple different harnesses parallely.
You carry context from one harness to another and must constantly remember which worktree contains which work. You, the builder, have now become the message bus. The "meat proxy" as some like to call it.
Longwave is an attempt to solve this: enabling more productive agents to run in parallel across your most ambitious projects, without the mental gymnastics. Put bluntly, the goal is to fit more agent hours into a builder's 24-hour day.
To achieve this, I started observing my own usage of agents over the past year and talked to a few friends, founders & builders that are heavily using agents in their day to day work. Here are some common bottlenecks.
The harnesses do not share the same UI
Codex may be running in one terminal, Claude Code in another, Cursor in a desktop window and OpenCode somewhere else.
The project is the same. The working environment is mostly the same as well. The interface is not. And that means you must switch between the different desktop apps and CLIs like a madman. Its even worse if you are trying to parallelize work that requires visual verification such as design, frontend, content creation etc. Now, on top of the harness UIs, you will need to have several running applications to actually view the output.
With Longwave, the idea is to let the user use their existing harnesses and subscriptions from the same app that works across desktop, mobile and web. The user can run applications, design canvases, video editors and more from the same application with the abilitity to interactively edit code and content all from the same platform. This should solve the problem of constantly having to switch between different applications and tabs.
Its objectively a much better experience for a builder running many parallel agents for their work. However, I wanted to go further and look at other deeper issues that show up as you start to run more and more agents.
Woeful worktrees
Git worktrees are good at one narrow thing: keeping two agents from editing the same checkout and overwriting each other's files. However, they leave you tracking which branch is checked out where. You have to constantly manage secrets so that all the worktrees have the updated secrets. Runing the same application locally in two different worktrees can cause port collisions and things to break in spectacular ways.
Oh and god forbid you try to check out a branch in a worktree which is already checked out in another worktree!
We have tried to solve this by simply coupling worktrees and branches into something called Longwave workstreams. The goal here is to simplify how parallel efforts are worked on and tracked by users so there is no need to think in "which branch is checked out where" anymore.
This, however, doesnt solve the other issue with parallelizing work at a large scale. Your hardware!
Your laptop becomes part of the bottleneck
Run several agents on one machine and the laptop becomes a space heater. This is especially painful when browser-use or computer-use work runs alongside development, testing or other active tasks.
There is also a safety problem. A computer-use agent on your primary workstation can reach personal files, browser cookies, passwords and API keys. You want an isolated computer where an experiment can fail without taking your working environment with it.
Longwave lets you distribute work across devices you own or through Longwave Cloud. Your laptop can remain available while another machine handles the longer-running or more sensitive task. The work keeps its identity, history and context when execution moves.
Firehose of things to review
You can launch several agents quickly. Reviewing and validating their output is harder than generating it. This is where productive token burn either becomes leverage or becomes a pile of slop you now have to inspect.
You may need to inspect code, check a test result, compare performance and work out whether two agents changed related parts of the product. Every context switch adds a reload cost. You remember the original goal and try to manually check if the agent achieved it. When it comes to a web app or a mobile app, this could mean u having to manually test the app after every change, then look at the code and then approve the changes once you are happe with both. As your app gets bigger and more complex, you realize this doesnt scale. You start to drown in slop.
Longwave lets agents perform performance reviews, run benchmarks and run end-to-end tests. We have built a custom experience for reviewing code changes. You can review video evidence from the running product instead of manually reading every change by default. You can also review performance impact of the changes. All from the same UI containing the evidence and the diff grouped intuitively. Its almost like the agents are not just writing code but trying hard to get their PR approved.
The next agent starts from zero
An agent can finish a useful turn and still leave you with the most annoying part: explaining the same context to the next agent.
The second agent sees a branch, changed files and perhaps a short summary. It does not know the original request, why the decisions were made, which checks passed or what remains unresolved.
You start trying to solve this by asking agents to write notes in markdown files. But soon you realize you have a bunch of stale markdown files that contain stuff no longer relevant to your company or even worse, completely contrary to the latest decisions you have made related to your company or your product. This is a common occurrence especially as a solo founder or a small company that is following the sacred doctrine of FAFO (f*ck around and find out).
Longwave makes it easier to handoff work from one agent to another by keeping a global temporal record of prompts and decisions that were made closely coupled with the completed work. The key here is the temporal aspect of this which lets a future agent easily figure out the latest decisions related to a specific product or feature and see how it evolved over time.
More agents. Less coordination.
Longwave gives you one place to run different harnesses, track changes, move agents across machines and review the completed work.
You can add agents without becoming the coordination layer. This gives solo founders and small teams more capacity and insane leverage. Longwave manages the growing complexity, so you can focus on decisions that need your attention.