Anthropic building its own source control is a sign of what’s coming: agent-scale development will force us to rethink parts of the software lifecycle we’ve treated as settled.
My view is that the unit of autonomy has to become larger than a coding task. An agent that writes a change and hands it off has automated one step. A software factory has to carry that change through integration, testing and release, and use failures to improve the next attempt.
The difficult part is the interaction between changes. Two changes can each pass their tests and still fail together. A passing test result is evidence about a particular version, not every version that comes after it. As more agents work in parallel, keeping that evidence connected to what actually ships becomes a much bigger engineering problem.
That’s why I wouldn’t measure a software factory by how many agents it runs or how much code they generate. I’d measure how much work reaches production correctly, how often engineers have to step in to fix or unblock the work, and how quickly the system recovers when it gets something wrong.
Faster coding is valuable. The bigger leap is making the entire system capable of absorbing it.
I am so excited about this launch today.
We're launching Autonomous Worker Agents, and I want to share why this is so important.
AI writes more of the code every month — but the work after it still eats most of the day. Software delivery has moved through phases: manual work, then scripts, then automated pipelines.
Worker Agents are the next phase, turning every pipeline step into a reasoning agent that handles the work between writing code and shipping it to production.
What makes this different from every other AI agent announcement you've seen: we built this to be safe to run in production from day one. Agents run inside the customer's own network boundary, sandboxed and scoped with their own identity and permissions.
They inherit the OPA policies, RBAC, and audit trails already in Harness pipelines. The governance is already there, and the agents inherit it all. If customers can't trust an agent in production, it doesn't matter how capable it is. That's the core innovation here.
And it's easy to get started. Anyone can author an agent in under 10 minutes, and Harness has pre-built and certified agents for the most asked-for use cases — code review, build autofix, feature flag cleanup, and manifest remediation. Those agents, and many more, are live in the Agent Marketplace now.
When we named the company Harness, the thesis was a safety harness for code. This is the same harness, extended to the agents acting on that code.
I wrote more on the architecture and what's shipping today: https://lnkd.in/e92jM2au
Dario Amodei wrote a 3,800 word essay on Saturday asking the AI industry to slow down.
Most of the reaction has been about what the labs and governments will do. That is an important debate. But the more actionable question for most businesses is what to do regardless.
If you run a company, this is the sentence to pay attention to:
"Given the accelerating rate of AI capability development, it's my worry that in 6–12 months such a swarm could be capable of taking over the entire internet with a persistent botnet (potentially causing hundreds of billions of dollars in damage)."
I don't think this is far-fetched. We already saw a small version of it in July.
About 700 OpenAI agents running a cybersecurity eval started working together, got out of their test environment, and spent three days inside Hugging Face's production infrastructure.
Here is what they did.
They got code execution through a dataset upload path. They grabbed Kubernetes, database, and cloud credentials. They moved into internal clusters. They wrote tools to fake their own activity logs.
OpenAI's monitoring first noticed something was off because of unusual identity-related API calls. That was eight days after it started.
APIs are all over that chain.
Most companies have a WAF in front of their public APIs and think that's API security. A WAF checks one request at a time against known bad patterns. It doesn't know every API that exists behind it, doesn't see all the internal service-to-service traffic, and can't tell that 200 individually clean requests add up to an attack.
Your business does not have to be using AI to get attacked by AI.
Protecting your business is your decision. Nobody else is going to make it for you.
We can slow AI down. We can't avoid it. Dario says 6 to 12 months. Slow the frontier and maybe it is 12 to 18. Open-weight models could make it sooner.
Pacing changes the date, not the outcome.
So what do you do now? Three things.
Number 1. Know every API you have. Internal, external, third-party, and the ones nobody registered. You can't protect what you don't know is there.
Number 2. Watch behavior, not signatures. Understand what is happening across the whole session, not whether one request matches a rule.
Number 3. Enforce at runtime. Scanning catches what you shipped. A swarm attacks what is running. You need something inline that blocks it and keeps a record the agents can't rewrite.
We started Traceable in 2020 to work on this problem, and that work is now the runtime protection layer inside Harness. But whatever you use, use something.
Ask your security team this week: if a swarm of AI agents started probing us tomorrow, what would actually stop it?
What a week in Europe spending time with AI engineering leaders and practitioners.
Grateful to have spoken at RAISE Summit in Paris and joined WeAreDevelopers in Berlin — two rooms full of the people actually building and shipping AI in production. The conversations kept circling the same theme: generating code with AI is the easy part. Getting it shipped safely and at speed is where teams are still stuck.
A few highlights:
- At RAISE Summit, I had a fireside chat with Lionel Laurent of Bloomberg: “AI Is Only as Fast as Your Slowest Process.” AI writes code at machine speed, but our pipelines were built for human speed. That gap is where AI ROI stalls. Closing it means rethinking how software actually gets shipped.
- At WeAreDevelopers, Daniel Gebler and I discussed the growing gap between AI-assisted development and production-ready delivery, and how autonomous agents are starting to close it.
- Also at WeAreDevelopers, I joined Christian Trummer, Milin Desai, and Tomislav Tipurić to talk about “The New AI Security Stack: Observe, Detect, Protect.” As AI spreads through every system, the way we secure and observe those systems has to change with it.
Thanks to everyone who came out, asked hard questions, and pushed the thinking forward. This is the most energizing time I can remember to be working on software delivery.

Coding agents can write a fix in 30 seconds.
Then they wait 20 minutes for CI to say it failed. And get back a red X and 4,000 lines of logs.
The bottleneck isn’t the code anymore. It’s the loop.
Agents need three things from CI:
- Fast validation. Run only the tests the change affects. Don’t rebuild what hasn’t changed.
- Failure context they can act on. The failed step, the relevant logs, the commit under test.
- A closed loop. Validate the next attempt without an engineer brokering every handoff.
An API that only triggers builds isn’t agent-friendly CI. It’s a doorbell.
That’s what we’ve been building at Harness with Test Intelligence, build caching, and our MCP and IDE integrations.
Build duration still matters. The metric that matters more: time from a failed attempt to a verified fix, and how many manual handoffs it took.
Otherwise you get very fast agents waiting on very slow pipelines.
Today, I'm excited to launch Harness Agent DLC: new products and capabilities across the AI agent development lifecycle.
When we started Harness, the vision was a safety harness for code. Until recently, that meant application code. Today, it also means agentic code: building and shipping AI agents.
An agent doesn't run the same way twice. It picks its own tools, APIs, and sequence of actions at runtime. I've watched this trip up some of the smartest engineers on my team. They write a test, it passes, and they move on. On the next run, with the same input, the agent can take a different path and land somewhere else entirely.
Software delivery pipelines assume code behaves the same way every time it runs. Agents break that assumption, and that's the real reason most agents never leave the pilot stage: shipping something you can't predict into production, with no way to govern it, is too much risk for most teams to take on.
With Harness Agent DLC, you can build, test, deploy, operate, and govern agents through the same Harness platform you already run for your applications, with the same pipelines and controls. Here's what's new at each stage:
- Build — agents go through the same CI pipeline as any other service. No new build system to learn.
- Test — AI Evals scores agent changes against your own datasets before they ship, so you can set real quality gates in CI/CD. AI Test Automation checks agent responses inside your app's chat interface, using plain English assertions instead of brittle test scripts.
- Store — Artifact Registry tracks every prompt, model, and skill version behind an agent release, so you know exactly what shipped and why.
- Deploy — Agent deployments bring the canary rollouts, approvals, and OPA policy we already run for Kubernetes to managed runtimes like Bedrock AgentCore and GCP Agent Runtime.
- Operate — AI cost management extends to every agent and model you run. AI configs let you test prompt and model changes at runtime and roll back instantly, no redeploy required.
- Govern — AI asset catalog auto-discovers every agent, skill, and plugin across your repos and assigns each one an owner.
- Security — Primitive scanning and AIBOM catch misconfigurations and risky dependencies before an agent ships. AI Firewall and agent discovery enforce policy once it's running, against prompt injection, tool misuse, and data exfiltration.
- AgentTrace — traces every run and every session, so you can see what an agent actually did and why.
Everything we've built for software delivery over the last decade, governance, orchestration, security, testing, you can now do the same for agents.
Massive credit to the teams that built this across every stage, build through govern.
Full details here: https://lnkd.in/dpAHBKuk