The Harness

I have rather high certainty that the way software is built is about to change dramatically, and that most vertical software will shift to general-purpose agents. The vertical SaaS economy is an economy of automating workflows that are the same every day; you look for the people who do the same thing fifty times a day, and you automate that. Software, in that world, is a workflow: a predetermined set of operations with a little flexibility in the middle, this is an NDA so go this way, this is another kind of contract so go that way. There’s an inverted way to do it. An agent is something that has complete discretion and maneuverability to accomplish a task you require. You give it a computer, and with that computer it accomplishes your goal. Go build it from scratch: it writes code, runs the code, finds the bugs, fixes them. There’s no path. You give an instruction, you get the answer. You don’t know or care how it did it, so long as you can trust the result. And as long as you’re willing to pay for the tokens, it keeps going, like an employee that never sleeps and always has more to do. Best of all, it keeps getting better on its own: the labs ship a new model every six months, and you get that for free.

If that’s where things are heading, the question for any vertical AI company is what to own. Agents can use tools, but the tools they use need to exist: first you build the tool, then you teach the agent how to use it. The agent has the typical tools, everything you can do on a normal computer, but some tools are special. Take Plaid; your agent by itself can’t connect to your bank account, so it needs something like Plaid. So the moat is whatever the agent needs to do its job. If the agent uses Plaid, then Plaid is good. If the agent uses LLMs, then LLMs are good. If the agent uses GPUs, then GPUs are good. Value accrues to whoever is serving the agent. The old SaaS moat was lock-in: a vendor holds all your data, and leaving is so expensive you never do. Agents erode that. If something just does the job, swapping one provider for another is cheap, so the durable position is no longer lock-in but ownership: own the tools the agent can’t do without, or own the industry outright. And not the trivial tools, book a meeting or get the weather, but the ones that are either proprietary and expensive, like Cadence and Synopsys, or built for human use and therefore bad for agents, or that have no open-source alternative and can’t be trivially coded. Those are the ones that involve large data, heavy compute, and real simulation. We’re not going to build a model that, pound for pound, beats Claude Code; that’s not the differentiation. The differentiation is on the tools. Whoever owns those tools owns the harness. Claude Code is a harness for coding and general-purpose work. The harness is the thing.

Take chip design, the hardest vertical I know.

There’s a bottleneck in semiconductors. We keep designing more ambitious chips every year (more transistors, more complexity, tighter timelines), and at the same time the supply of people who actually know how to design and verify them is shrinking. Verification engineering, the job of proving that a chip does exactly what it’s supposed to do before you commit it to silicon, is a growing-in-demand role in the US. But the average age of the people doing it is over 40, and fewer people are going to school for it. So you have demand going up and the talent pipeline going down. That’s a bottleneck, and bottlenecks like that are exactly where I want to be investing.

What designing a chip actually looks like

In semiconductors there are still blueprints. Even though an engineer writes code, someone writes a document first, a multi-hundred-page document that specifies, in detail, exactly what the chip is supposed to do. Going from that document to a testbench that verifies everything you built is the heart of the job, and it’s enormous.

Then there’s the physics. A chip runs on a clock. The clock ticks, and everything in between has to happen in time. If you don’t organize things correctly, you miss the clock cycle and everything is messed up. To know whether you got it right, you simulate, and those simulations produce waveforms, traces that show you the values of every register over time. These waveforms are, for lack of a better phrase, from here to the moon. They’re gigantic. So if you want an agent to help here, it has to observe and reason over that kind of data, a kind of tool use that is simply not typical for your common coding agent.

After the logical design, you go into physical design: figuring out how the thing actually maps onto the surface of the silicon, so that the wires don’t cross each other and the timing still holds. Then you simulate again, but now you’re looking at things like power, how much each part of the chip is going to consume. And there’s a whole other world beyond the digital part. A lot of what we picture when we think of semiconductors is digital logic, just gates. But there are also analog circuits (resistors, capacitors, the continuous analog parts of a chip that don’t reduce to gates), and there’s far less good tooling there. A lot of what the incumbents sell doesn’t really work well once you’re thinking in analog terms.

The other thing to understand is how slow all of this is. The simulators are extraordinarily complex, expensive physics engines. To run a real one you use a supercomputer. You kick off a job, you go home, and you come back the next day to your results. And because the supercomputer is a shared resource, everyone in the building is waiting in the same line. The entire design loop is gated by these long, expensive, batched simulation runs.

The harness, in silicon

ChipAgents is a harness, specifically for chip design.

The goal of a company like this should not be to win a hand-to-hand fight with the general-purpose models. There’s no point trying to beat the big labs on a benchmark for writing code. You will lose that fight, and even if you won it this quarter you’d lose it next quarter. Where you win is on complex tasks that require specialized tools. Furthermore, these tools need to be optimized for agentic use. In semiconductor design there are plenty of simulation tools that are GUI-based and slow, both suboptimal characteristics in an agent world. That’s the moat. It has very little to do with whose language model is slightly better.

Besides the harness, a vertical AI company can build domain-specific models. LLMs are the brains of agents, and it’s unlikely anyone outside of a big lab will build a “smarter” model, but there is room to build custom models that act as sophisticated sensors on a very particular type of data. Think about the protein-folding models. They may use transformers under the hood, but they’re trained specifically to do one hard thing extremely well. You can do the same thing in chip design. For example, instead of running a full-precision power simulation overnight on the computer cluster, you can train a domain-specific model that anticipates power consumption directly. It won’t be exact, it’s an estimate. But it can tell you, immediately, “this particular section of the chip looks like it’s drawing too much power, take another look. You get that answer in seconds instead of the next morning, you iterate, and you delay the big, expensive simulation until you actually need it. That’s the kind of capability a general-purpose model will never give you, because nobody at a general-purpose lab is training a model to estimate power dissipation on a circuit.

The tools and the models compound. Once you have the tools, you can leverage feedback loops to enhance models continually. You begin by using reinforcement learning to teach a model to use your own tools better, once you have the testing data, and eventually you train models from the ground up. With the tools, the feedback loop, and proprietary models, a company’s market position becomes virtually unassailable. No one has reached that stage yet, in chips or anywhere else; the work is to climb toward it.

There’s one more reason the harness is the right place to stand. The incumbent tools, the ones that have defined this industry for decades, were built for humans, not agents. This isn’t unique to chips. The costly desktop CAD software used by engineers in architecture, mechanical design, and circuit design is typically proprietary, lacks APIs, and wasn’t built with LLMs in mind. Historically, to use a simulator, you would type a command into a terminal, or open a tool with a big vendor logo on top and click around. You can script them, but the surface is fragmented and awkward, and a lot of the real work still happens by hand. Learning to drive all of that reliably is its own hard problem, a very specific kind of computer use. Once an agent can do it, the agent becomes the thing the engineer interacts with, and the old tools recede into the background.

Become the front end

This is the part I find most strategically interesting about vertical AI companies.

Think about how the incumbents are structured. The hardware description language itself, Verilog, is free. Everybody uses Verilog, nobody cares, Verilog is free. That’s the front end. They make their money on the back end: the simulators, the waveform analyzers. The cool thing about agents (whether it’s an agent for finance, for law, or for chips) is that the agent becomes the front end of the front end. The heavy tools get called by the agent in the background to get the job done, and we control the agent. So before, an engineer interacted directly with a vendor’s simulator, with the vendor’s logo on the screen. Now that’s not happening. Our agent turns the simulator on in the background, pulls the data, and the engineer is only ever interacting with us. As long as the results are good, the user does not care what’s running underneath.

That changes the balance of power. If we ever decide that having our own simulator is a good idea, we just point the agent at our own simulator instead, and nothing about the user’s experience changes. If there’s a new back-end procedure that needs to be done somewhere in the design flow, it’s easy for us to build it and upsell it, because we own the interface. We are the UI. We are the front end. Whoever controls the agent gets to delegate sub-actions to whatever they want, and that’s a lot of power. We can intentionally go from using a vendor’s simulator ninety percent of the time to ten percent of the time. That gives the customer more pricing power against the incumbent, and it gives us more pricing power against the customer. Owning the front end is what lets you slowly take over the back end on your own schedule.

Innovator’s dilemma

Let me be precise about what this company is and isn’t trying to do, because this is where a lot of people get the strategy wrong. Right now we’re a complement to the EDA tools, not a direct competitor. Before us, the engineers were just writing code by themselves in a normal IDE, something like VS Code. So in a sense we’re the Cursor for chip design: we help them write the code and write the tests, they send it off to Cadence or Synopsys to be simulated, the simulation comes back, and our agent reads the results, looks for errors, and traces them back to the spec. We’re selling to the same people doing design, testing, and verification.

Those physics simulators are extraordinarily precise, and they took decades and billions of dollars to build, and that’s fine, we’ll keep using them.. But they’re slow and expensive, so today you run them constantly just to get sanity checks. Our goal is to use them less, to lean on fast approximations during the design loop and save the full supercomputer run for once or twice at the end. When that happens, the incumbent’s pricing power goes down. It’s not that we’re displacing EDAs; we’re not doing what Synopsys does. But we accelerate the lifecycle and do more and more before we ever have to reach for their tools, and that makes those tools relatively less important. That’s the innovator’s dilemma applied to chip design: AI lets us take a lot of shortcuts. Over time I think EDA, the simulation layer, becomes a smaller part of the market, and the value moves to the front end, to the people actually designing and making the thing. The old tools are sold per seat. If you’re accelerating the engineering work itself, you eventually charge a percentage of R&D instead, and when a customer is spending a billion dollars designing chips, a few points of that is an enormous business.

That’s the opposite of the other camp. There’s a well-funded effort that takes the maximalist position: you won’t need anybody, you’ll just type a prompt and a finished chip comes out the other side. They claimed this years ago, before AI got really good. I’m an AI maximalist too, I genuinely think AI is going to change everything, but you have to play with the market as it actually exists. The iterative approach, fitting into the workflow as it runs today and accelerating each step, is more likely to get adopted.

Why can’t the incumbents just do it?

The obvious question is why EDA companies don’t simply take the AI route themselves. The answer is talent. The kind of people who can actually do this work are extraordinarily scarce, on the order of thousands in the entire world, and they command very high salaries. They will go to a startup and take equity. There’s no way the compensation structure of a thirty-year-old EDA company can digest this personnel, and those people don’t want to work there. You go to an AI conference and everyone wants to be at a startup, or at one of the big labs. EDA isn’t cool. So there’s no realistic way for the incumbents to assemble a team of fifty or a hundred of these people to go build this, even though they can see it coming. That’s the opening.

How is venture capital changing?

For a long time the instinct in venture was that good software was enough. I don’t believe that anymore. AI is eroding the last standing barriers to entry. Software has eaten the world, and the world of software now lives in the boring plane of compressed margins. A company that just sells software is not differentiable; software is a commodity now, or it’s going to become one soon.

So the real question I keep asking is: where do you draw the line? Software generation keeps getting better, for free, every six months, so where do you draw a line you can still defend? For me, the answer is to go toward harder technology, where more things have to work out, where there’s real capex, where you have to train your own models or earn access to data and relationships that other people simply don’t have. That’s the opposite of vertical SaaS, which just gets hammered on margins. It’s vertical integration: the Tesla or SpaceX or Apple model, less like selling software to construction companies and more like building the construction company itself, fully digitized, fully agentic, end to end. It’s harder, and it’s higher capex, which is exactly the point. When you’re that vertically integrated, software stops being the product and becomes an advantage layered on top of something hard.

Chip design is about as hard as it gets. The bottleneck is real, the talent is aging out, the tools are decades old and were built for humans, not agents, and the feedback loops are measured in overnight supercomputer runs. It’s close enough to software that I’m confident AI will work well, but specialized enough that nobody is going to eat our lunch overnight. There are only ever going to be a handful of serious companies going after a problem like this, five or six, not five hundred. The winning move is to own the front end and let the agent quietly take over everything behind it.