DEV Community: Yuhao Xu

The "Agent Tax": Why the Era of Subsidized AI is Coming to End

Yuhao Xu — Thu, 12 Feb 2026 09:58:11 +0000

The Hidden Math Behind the AI Hype
Last month, Kuse hit a milestone that most founders dream of: 500,000 users and a record-high $11M ARR. By all vanity metrics, we were winning.
But behind the scenes, I was staring at a spreadsheet that told a different story. A story that eventually led me to make the hardest decision of my career: nuking our most popular pricing plans and intentionally driving away 99% of our "growth."
Why? Because I realized that in the race for AI dominance, we were accidentally running a high-interest charity.

The "Unlimited" Illusion
In the early days of the SaaS boom, "unlimited" was a marketing goldmine. Storage was cheap, and bandwidth was a commodity. But in the age of Agentic AI, intelligence is a luxury good.
We had power users—the kind of users you'd usually celebrate who were paying us $20 a month while burning through $1,000+ in raw API costs. They weren't doing anything wrong; they were simply using our agents for what they were built for: complex, iterative, high-stakes tasks like autonomous coding and deep research.
Because Kuse builds real agents, the loops are relentless. Unlike a simple chatbot that gives a one-shot response, an agent reflects, calls tools, hits errors, and retries. Every "thought" in that loop has a price tag attached.
We weren't just a software company; we were an unpaid middleman for Big Tech’s compute.

The Three Hard Truths of the AI Economy
As I deconstructed our bills, I identified three structural traps that every AI founder is currently facing:

The API Trap There is a massive, unspoken disparity in the market. Giants like Google, OpenAI, and Anthropic can offer $20/month consumer subscriptions because they own the "oil"—the compute. As an application layer product, we buy that oil at retail price. To justify our existence, we have to provide intelligence that is 10x more specialized than the base model. But here is the catch: 10x intelligence requires 10x the tokens. If an AI tool is cheap, it's either sacrificing the quality of reasoning or bleeding out in silence.
The "Agent Tax" Chat is a 1:1 interaction; it’s linear. Agents are 1:N iterations; they are exponential. When an agent "thinks" about a problem, it drags along a massive context window in every loop. This "Context Bloat" is a silent killer of margins. You’re not just paying for the answer; you’re paying for the entire cognitive process.
Unit Economics > Vanity Metrics The VC-funded mantra of "growth at all costs" is a death trap in 2026. In traditional SaaS, your 10,000th user is almost pure profit. In Agentic AI, if your unit economics are broken, your 10,000th user just brings you closer to bankruptcy.

This week, we moved our floor to $39.9. We moved to metered billing.
The backlash was instant. My inbox was a war zone. One student told me we "lost the soul of the product." But the soul of a product doesn't matter if the company doesn't exist in six months.
We’ve lost thousands of users. But the users who stayed? They are the ones solving $10,000 problems. They understand that if you want a digital employee that actually finishes the job, you have to pay the salary of the compute required to run it.

The era of subsidized AI is ending. We are moving from a world of "AI Wrappers" to a world of "Sustainable Intelligence."
I’d rather have 1,000 users who value the depth of Kuse’s reasoning than 100,000 users playing with a $10 toy.
To my fellow founders: Take a long, hard look at your token bills tonight. Are you building a business, or are you just a very expensive bridge for someone else's API?

From Information Containers to Work Systems: How AI Products Shift from Information to Productivity

Yuhao Xu — Fri, 30 Jan 2026 03:07:06 +0000

Introduction

When designing AI products, the first challenge product managers face is often not a specific use case, model capability, or interaction pattern. It is something more fundamental - the object of design itself has changed.
In the internet era, products were designed around information. The core problem to solve was how information should be produced, organized, distributed, and consumed. As a result, product forms gradually converged into different kinds of information containers.
In the AI era, products began to directly carry productive capacity. The question is no longer how information should be presented, but how AI’s productive capability can be organized, invoked, and sustained over time.
Once the design object changes, the assumptions behind existing product methodologies and structural models begin to break down.
If we were to describe this shift with a simple analogy:

Internet products are like newspapers, while AI products are more like offices.
It reflects a fundamental shift in the design object, product structure, and value loop.

Internet Products Are Designed Around Information

The internet solved an information problem: how information is produced, organized, distributed, and consumed.
As a result, the design object of internet products was clear from the beginning - information itself.
The core responsibility of a product manager was to design information containers that fit specific contexts:

where information lives, how it is structured and distributed, and how users continuously consume it
Over time, information containers evolved through several clear stages:

In other words, designing internet products has always meant designing a newspaper. Even though the form of the newspaper changes, the design object remains information, and the design paradigm consistently revolves around information containers.

AI Products Are Designed Around Productivity

The emergence of AI is not merely about generating content faster. It introduces a callable productive force directly into products - one that can participate in task decomposition, path selection, execution, and result verification.
Under this premise, product managers face a fundamentally new question:

How do you design a work container that can host, schedule, and constrain this productive force?
This is the most essential difference between AI products and internet products.
Similarly, work containers have also gone through stages of evolution:

The real dividing line is not whether a product "has AI", but whether its container is designed for AI-driven productivity.
To answer what kind of container can truly support AI productivity, we must understand how humans work, how AI works, and how the two can collaborate within a shared structure.

The File System as a Shared Work Container for Humans and AI

Why File Systems Fit Human Work
Human work is not about producing one-off outputs. It is a continuous process of moving something from a historical state toward a target state.
Every step forward happens under constraints: progress toward a goal always comes with real cost.

The Temporal and Spatial Structure of State
Any working state exists simultaneously across two dimensions.
In time, it inherits from the past, exists in the present, and points toward the next step.
In space, it acts on concrete objects, with clear scope, granularity, and cost.
For work to progress continuously, states must be stably expressed, accessed, and operated on.
Files as the Minimal Expression of State
Files do not merely store content. They express state.

Historical documents express completed states
Active working files express ongoing states
Strategy or goal documents express intended future states Files make states visible, inheritable, and operable.

Folders as Containers for Managing and Advancing State
Folders are not just for organization. Their primary role is to manage the full context of a piece of work.
Within a folder, historical, current, and target files coexist, collectively defining scope, origin, and next steps. They stop being isolated content and become a continuous work state.

This does not mean file systems are the only way to advance work. But through long-term practice, they have become one of the most stable and widely adopted structures for organizing and advancing work since the birth of computing.

Why File Systems Also Fit AI Work

Once we understand the structure of human work, AI’s working logic reveals a similar - but more constrained - pattern.
How AI Works: Tokens and Context
At a fundamental level, whether generating text, writing code, or planning tasks, models always do the same thing:

given a context, predict the next token based on existing tokens.

An "output" is essentially a sequence of predicted tokens.
Whether the output meets expectations depends not only on how capable the model is, but on which tokens constrain it before generation.
Those context tokens determine three critical factors:

whether the goal is clear, whether granularity is controlled, and whether scope is well defined.

The Structural Constraint of Context: One-Time Windows
Context itself has a fundamental limitation. It is not a persistent workspace, but a one-time computation window.
This means that before every inference, the system must reconstruct an appropriate context for the model.
The Economic Constraint of Context: Token Cost
Context is also a cost-bearing resource. Every token participates directly in inference.
More tokens mean higher computation cost and latency. As a result, AI product design is not about giving models more information, but about constructing the smallest sufficient context within a limited token budget.

File Systems as an External State Space for Context

When work states are stably stored in an external system, context no longer needs to be fully loaded at once.
The system can selectively retrieve, trim, and combine relevant state to construct just-enough context for the current task.
The file system functions as this external state space.
Files and folders are not piles of information, but accumulated state representations centered around concrete work. They define clear object boundaries, establish explicit scopes, and allow historical and current states to be read together.
A Proven Structure: Coding Products
This structural advantage has already been validated in coding products.
Software evolves through continuous maintenance and modification of concrete code files. Each change is written back into the file system, and subsequent work proceeds from those states.
AI demonstrates sustained, controllable productivity in programming not because it is inherently "smarter" in this domain, but because code already exists within a highly structured, evolvable file system.
How File Systems Amplify AI Productivity
Looking back at AI’s working nature, file systems do not amplify intelligence. They amplify the probability that AI outputs meet expectations, and the likelihood that work can progress continuously.
For this reason, this design will not be "eaten" by stronger models.
Models get stronger. File systems ensure that strength lands continuously, economically, and reliably in the right place.

When Humans and AI Collaborate in the Same File System

When a file system satisfies both human needs for expressing work state and AI’s structural and cost constraints for context construction, collaboration fundamentally changes.
From Instruction Loops to State Handoffs
Collaboration no longer primarily happens at the conversation layer. It revolves around work state itself.
Files become shared working objects. Folders define shared boundaries.
Humans adjust direction by modifying goal and constraint files. AI advances execution based on existing state.
Collaboration shifts from instruction ping-pong to state-based handoff:
humans judge and validate, AI executes and advances.
From One-Off Outputs to Evolvable Work Assets
Once AI outputs are stably written into the file system, their nature changes.
Outputs are no longer disposable content. They become inheritable, modifiable, reusable work states.
Historical files record completed work. Active files carry ongoing progress. Goal files point toward intended destinations.
Work becomes a continuous trajectory rather than a pile of isolated results.
From Operational Momentum to Systemic Potential
Within this structure, systems begin to exhibit momentum and latent potential.
Work no longer depends on constant human intervention. It advances under established state and constraints.
Humans define goals and handle exceptions. AI executes within scope. File systems accumulate process and assets.
An “office that runs itself” does not emerge because AI replaces humans, but because work is placed inside a structure that both humans and AI can jointly advance.

Conclusion

From the internet era to the AI era, the center of product design is shifting from how information is presented to how productivity is organized.
When work is understood as continuous state progression, the core of product design is no longer entry points or interactions, but whether the system can carry that progression.
The file system is not a preference. Under current technical and cost constraints, it is a structural decision that makes human-AI collaboration viable.
What it defines is not a feature set, but a design judgment about whether AI can be absorbed into real productivity.

I Built an Open-Source Cowork in 24 Hours with ZERO Rust Experience — and the Agent Builts Itself

Yuhao Xu — Tue, 20 Jan 2026 08:43:26 +0000

I walked into this with exactly zero Rust experience and a stubborn belief: building an agent shouldn’t require a megachurch of frameworks. Twenty-four hours later, I shipped a Rust-native AI Agent desktop for non-dev that compiled to a 16MB tiny binary, a simple while loop with Skills, MCPs supported. And the most important part: BYOK (Bring Your Own Key) and even local models!

Call it technical minimalism.

The Stack

Rust (from zero to shipping in one day)
Long term memory: File system as persistent, queryable context
Loop: A single while loop coordinating I/O and tool calls
Tools: Built-in file tools (read, write, bash) + MCP-compliant providers (extensible)
Sandboxing: A simple docker container would isolation most risks.

Secret Sauce

Keep state in plain files and directories.
Keep orchestration in a simple loop, not a framework
Teach the AI to read and write its own operating context, in files.

What I learnt:
1) You don’t need an agent framework
Agent “framework” is almost always over abstraction and adds complexity.

Just a simple while loop:
1. Observe: read inputs, logs, and task files
2. Decide: ask the model for the next atomic action
3. Act: call a tool (MCP) or write to disk
4. Reflect: append outcomes to a local journal

2) The File System is all you need
Vector stores and RAG farms are great—until they become speculative overhead.

Everything as Files: Tasks, plans, diffs, decisions, and logs live as plain text and JSON.
Modern RL training methods have trained models to work super well with Linux files systems.
Using the FS as the “long term momery” makes persistence trivial and recoverability obvious.

3) The Surreal Mirror: AI Coding reproduces itself.
Of course, I use an AI agent (Claude Code) to work for me.
The Open Cowork is basically a GUI with a CC-like agent behind it. It’s super interesting to see CC can reproduce itself in Rust.

4) Security as a First-Class Citizen
Agents are powerful, but power without boundaries is a liability. They are potentially vulnerable to bad actors and prompt injection risks or even bugs. For non-devs, security isn’t just a feature—it’s the foundation.
By implementing hard sandboxing (like Docker) and strictly whitelisting system commands or network calls, we ensure the agent remains a helpful tool, not a system threat.

The entire codebase can be summarized in the loop below:

Of course it's still early, any feedback is welcome!

I asked Claude Code to build the "Open Cowork" for 48 hours non-stop

Yuhao Xu — Mon, 19 Jan 2026 05:35:30 +0000

Claude Cowork is a fascinating idea for non-devs, but I wanted a version that was open-source, lightweight, and strictly model-agnostic.
So I spent the last 24 hours with Claude Code and here it comes:

Native Rust, Zero-Wrappers: This isn't just another agent wrapper. It's a ground-up implementation in Rust. No heavy dependencies, no Python bloat, and no reliance on OpenCode/AgentSDK. Just raw performance and a tiny binary.
Docker Sandboxing: Since agents execute code, security is paramount. Open Cowork runs commands inside a transient Docker container.
BYOK (Bring Your Own Key): Use OpenAI, Anthropic, or run entirely offline with Ollama/Local LLMs. You own the keys and the privacy.
Skills, and MCPs: It can already handle complex document tasks (PDF, Excel, etc.) out of the box.

The Development Story: The most interesting part is that I had zero Rust experience before this weekend. It was a surreal experience: an AI agent (Claude Code) helping me build a faster, secure, and open-source version of "itself."

The project is live on GitHub: Open-source Alternative for Claude Code Desktop App
It's still very early, and there's a long roadmap ahead.
Any feedback is welcome!

I asked Claude Code to build the "Open Cowork" The project is live on GitHub: GitHub - kuse-ai/kuse_cowork: Open-source Alternative for Claude Code Desktop App It's still very early, and there's a long roadmap ahead. Any feedback is welcome!

Yuhao Xu — Mon, 19 Jan 2026 05:29:37 +0000