Temps de lecture : 4 min
Table of Contents
Key Takeaways
- Valuation signals a real problem: Blacksmith’s $1B valuation confirms that continuous integration at scale is still fragile — and companies are paying to fix it.
- AI-generated code breaks pipelines: More agents writing code means more CI volume, and most stacks were never built for that throughput.
- Trust is the bottleneck: As Jayaprakash put it, the real question is whether AI-written code can be trusted — and trust is earned through repeatable, observable validation, not demos.
The Round Itself
Blacksmith raised a $66 million Series C led by Sequoia, pushing its valuation to $1 billion. For a company that builds continuous integration infrastructure — the boring, unglamorous plumbing that builds, tests, merges, and validates every code change — that’s a staggering number. But when you understand what CI actually does in production, the valuation starts to make sense.
The company’s co-founder and CEO Aditya Jayaprakash framed it around pain. People are drowning in CI. Most companies can’t keep up with the volume of CI they need to run, especially now that AI agents are writing a growing share of the world’s software. And when agents write the code, the question shifts from “does it build?” to “can we trust it?”
The metrics back it up: 17x annual recurring revenue growth, over 90 million CI jobs executed, and customers like Mercury and Granola. This round lands just two months after a $45M Series B at a $550M valuation. A year earlier the company was valued at $60M. Total raised to date: $125 million.
Here’s what actually happens in production: that kind of growth curve is not a vanity metric. It’s a signal that teams are hitting a ceiling with homegrown or legacy CI and writing checks to get past it.
Why CI Is the Wrong Thing to Ignore
Let me be specific. Continuous integration in most early-stage stacks is a GitHub Action or a Jenkinsfile someone wrote two years ago and nobody owns. It works fine at ten commits a day. Then you onboard a few AI agents, commit volume triples, and suddenly your pipeline is the bottleneck. Builds queue. Tests flake. Merge queues back up. Developers context-switch while waiting and ship more bugs to avoid the wait.
The demo worked. Production didn’t. Here’s why: CI was never designed by most teams — it accreted. Nobody sized it for throughput. Nobody added observability. Nobody restricted flaky tests. It’s automation in the sense that a cron job with no alerting is automation, which is to say, it’s not automation — that’s a liability.
The real cost is: developer hours lost per week, merge queues that stretch to hours, and an ops team pulled into incident response because a bad merge slipped through a cache that went stale. That’s the number that should sit next to the Blacksmith valuation, because that’s the pain being purchased away.
AI-Generated Code Raised the Stakes
There’s a version of this story where AI code generation makes life easier. In production, the inverse is usually true: cheap code is expensive validation. When agents can open dozens of pull requests an hour, the CI layer is now the trust boundary. Every AI-authored merge needs to clear the same bar, and the bar has to be fast enough that fixing a pipeline failure doesn’t outweigh the value of the change.
Jayaprakash is right that the question is trust. But trust is not declared — it’s the result of repeatable, observable, fail-closed validation. If your pipeline silently falls back to a previous test run or skips a slow job, you’ve got a false-positive machine. And a false-positive machine at tripled throughput is worse than a slow pipeline, because it makes failure look like success.
This isn’t theory. I’ve watched teams run CI jobs on shared hardware with no per-job container isolation, and a corrupted cache took six hours to trace. We built OpenClaw and Hermes after seeing variants of that story repeat across startup infra stacks. The fix wasn’t sophisticated. It was structural: isolated runners, explicit failure behavior, observability at each stage, and no silent skips.
What This Means for Your Stack
Not every company can rebuild CI from scratch. Not every company needs managed CI at a one-billion valuation. But there are incremental paths. Here’s where I’d start:
- Measure before you migrate. Track queue time per job, median build duration, flake rate, and how often merges wait. Most teams are surprised by how much the numbers differ between tooling and reality.
- Isolate every job. Containers or ephemeral runners, one job per container, no shared caches that outlive the build. Shared state is where production fragility hides.
- Make failure explicit. If a required test can’t run, the pipeline fails. No silent passes. This is the single highest-leverage change for AI-generated PR volume.
- Watch the integrations. CI is coupled to GitHub, the registry, the deploy target, and the secrets manager. Most CI incidents start on one of those boundaries.
- Treat flaky tests as on-call work. Not a backlog item. Flakiness compounds with throughput, and throughput is about to rise.
The infrastructure layer around AI code is where the next wave of operational debt will be decided. Most people get this wrong: they optimize the agent and ignore the runner. The agent gets the demo. The runner gets the incident.
Blacksmith’s $1B valuation is a bet that this problem is big enough, and urgent enough, for companies to pay to solve. From where I sit in production, that bet looks structural — CI stopped being a first-year ticket and started being an ongoing operational concern the moment AI writing volume crossed the threshold.