The Cleanup Layer Is the Real AI Agent Market

Three days ago Charlie Labs shipped a Show HN with one of the cleanest pivot statements I have read this year: “We pivoted from building agents to cleaning up after them.”¹ Their founder spent close to two years building a cloud TypeScript coding agent. He shut it down because heavy agent use was producing more PRs, more drift, more stale dependencies, and more half-finished maintenance work than his team could keep up with. The new product, Daemons, is a config format for recurring maintenance roles defined in .agents/daemons/<id>/DAEMON.md files that triage bugs, update docs, watch for merge conflicts, and review stale PRs continuously.²

The pivot framing is the real signal. Not “we built better agents.” “Agents create work. Daemons maintain it.”²

That sentence names the market the rest of the industry is also racing into, and it explains why my own production setup looks the way it does. The durable AI agent market is not the layer that generates work. It is the layer that proves the work is correct, bounded, reversible, and worth signing. Generation is becoming commoditized inside model APIs. Proof is the durable layer because it is what every customer with a P&L actually pays for.

TL;DR

• Charlie Labs pivoted publicly from a coding agent to a cleanup product because agents create operational debt faster than they pay it down.
• The pattern is not unique: InsightFinder raised $15M for “where AI agents go wrong” on April 16, and Palo Alto Networks paid $3.35B for Chronosphere in November. The proof layer is consolidating.
• 57% of organizations now run agents in production; 69% of agent decisions still require human verification. The verification gap is the market.
• My own scar-hook count went 84 → 123 in 26 days. None of those hooks generate; all of them prove.
• Generation is the body of work. Proof is the back of the cabinet, and that is where the durable margin lives.

The Pattern Charlie Labs Is Inside

Charlie Labs is not the only company quietly recategorizing itself this quarter. The same week as the Daemons announcement:

• InsightFinder raised a $15M Series B on April 16 specifically pitched as “where AI agents go wrong”: anomaly detection plus root-cause diagnosis plus automated remediation for agent-driven incidents.³
• Sonarly (YC W26) is shipping production alert triage, RCA, and fix PRs that sit on top of Sentry, Datadog, and Grafana, agents that read the post-incident wreckage and clean it up.⁴
• Cekura (YC F24) is doing automated testing, monitoring, and simulation for voice and chat agents: quality assurance as a recurring runtime, not a pre-launch milestone.⁵
• Langfuse, Arize Phoenix, Braintrust, Datadog LLM Observability, and Fiddler are all racing to be the tracing-and-evaluation plane for agent runtimes.⁶⁷⁸⁹¹⁰
• Lakera Guard and Fiddler Guardrails are productizing runtime control: prompt-injection blocks, tool-abuse detection, policy enforcement.¹¹¹²
• Palo Alto Networks paid $3.35B for Chronosphere in November to get observability into the security stack ahead of the agent wave.¹³

The companies above sell different surfaces (alerting, evals, tracing, runtime guardrails, code-level maintenance), but they all live downstream of one fact: an agent’s output cannot be shipped on its word alone. Somebody, or some other piece of software, has to confirm the work happened the way the report claims it happened. That somebody is the proof layer, and the proof layer is the part of the agent stack that has revenue today.

Charlie’s framing is the cleanest way to say it: agents create proof obligations faster than they create finished work. The proof obligation is the unit a customer pays for. The agent that creates it is increasingly free, because the foundation labs subsidize it as a feature of the model.

The Verification Gap, In Numbers

One recent market synthesis lines up with the founder anecdotes. Three numbers are doing most of the work in this thesis:

• 57% of organizations now run AI agents in production, up from 51% the prior year.¹⁴
• 72% of enterprise AI projects involve multi-agent architectures, up from 23% in 2024.¹⁴
• 69% of AI-powered decisions still require human verification before they are actioned. 32% of teams cite quality as the top barrier to production deployment.¹⁴

The first two numbers describe the surface area of agent deployment. The third describes the throughput cap. Customers who run 100 agent decisions a day are still doing 69 verifications by hand because the tooling underneath them has not closed the loop. Every product on the proof-layer list above is a wedge into that 69%.

Translate the gap into procurement language and the thesis writes itself. A buyer with a budget of $X for “AI agents” can spend it on generation (more agents, faster) or on proof (fewer false positives, more autonomous decisions, less human-in-the-loop). The marginal generation dollar buys diminishing returns once the verification queue is full. The marginal proof dollar uncaps the queue. That is where the budget moves, which is why Sonarly, Cekura, InsightFinder, Charlie Labs, and the observability incumbents are sucking the air out of the room.

My Production System Is The Same Pattern, Smaller

I have been on the proof side of this market from the first day I ran an agent in production. I just did not have a name for it. The closest thing to a generation-side artifact I ship is a single completion report. The cleanup-side artifacts are everywhere.

A snapshot of my scar-hook orchestrator on April 24, 2026:¹⁵

• 123 hook files on disk, up from 84 on March 29, a 47% growth in 26 days. Every new hook is a guard added in response to a specific production failure.
• 88 skills in the registry, scoped task packs that constrain what an agent is allowed to do.
• 26 hook matcher rows across 15 lifecycle event types in ~/.claude/settings.json.
• Phantom verification dropped from 12% of sessions to under 2% after the hedging-language hook shipped.¹⁶
• Four named answer-shaped failure modes: phantom verification, malformed tool scenery, skipped dependency, summary laundering.¹⁶
• Two trust-dialog bypass CVEs in 37 days (CVE-2026-33068, CVE-2026-40068). Both required user-side audit, not just vendor patching.¹⁷

None of those hooks generate work. All of them prove (or refuse to prove) work that an agent generated. The scar count grows because each new agent capability surfaces a new way for an answer to be a costume for a tool that never ran. The growth curve is a small-scale proof of the market thesis: generation expands attack surface for proof. Proof has to compound to keep up.

That is the same shape Charlie’s team hit at Charlie Labs. The same shape the observability vendors are racing to capture. The proof problem does not stop at completion-report verification. It includes credential exposure, destructive operations, task drift, output quality, resource exhaustion, cross-project contamination, and trust-bootstrap compromise.¹⁵¹⁷ Each one is its own row in the cleanup taxonomy, and each row supports a vendor or two.

The Counter: Cleanup Was Always The Market

The strongest objection to this thesis is “old wine in new bottles.”

Cleanup has always been the market. SRE, QA, CI, code review, security scanning, observability, dependency bots, incident response: those are all proof-layer disciplines, and they together account for a substantial fraction of every engineering org’s spend long before agents arrived. Agents do not create the category. Agents accelerate the volume.

That counterargument is correct on the category and wrong on the magnitude. Three things change when agents enter the loop:

1. Volume. A coding agent generates dozens of PRs a week instead of a single engineer’s two or three. Documentation drifts faster. Dependencies stale faster. The maintenance queue compounds at agent speed, which is faster than human-led cleanup queues compound.¹
2. Failure modes. The four answer-shaped failures named above (phantom verification, malformed tool scenery, skipped dependency, summary laundering) are not bugs the existing CI/QA/observability stacks were designed to catch. The existing stack catches “the test suite returned non-zero.” It does not catch “the agent skipped the test suite and reported success.” Each failure mode requires a new gate.¹⁶
3. Reversal cost. A bad PR a human submits gets reverted with a commit. A bad PR an agent submits, in a chain of 30 PRs that other agents have already built on, takes a week of forensics. The reversal cost is what makes the proof layer non-negotiable rather than nice-to-have.

The category is old. The magnitude is new. New magnitude funds new vendors.

The Other Counter: Consolidation Risk

The second strongest objection is consolidation risk. If Anthropic, OpenAI, GitHub, and Datadog absorb the proof layer natively into their platforms, every standalone cleanup startup gets squeezed. There is real precedent: Datadog absorbed APM startups, GitHub absorbed Dependabot, Anthropic ships hook scaffolding inside Claude Code natively.

The consolidation argument is real but smaller than it looks, because the proof layer has structural reasons to live outside the model.

The most important reason is the one The Repo Shouldn’t Get to Vote on Its Own Trust names: the artifact being evaluated must not help make the trust decision.¹⁷ A model that grades its own output is the in-house auditor problem. Customers buying compliance-grade verification will not accept the model vendor as the verifier of last resort. That structural argument creates space for at least one independent proof-layer vendor per regulated vertical, no matter how aggressive the platforms get.

The second reason is heterogeneity. Agent stacks combine OpenAI, Anthropic, in-house models, third-party tools, vector databases, and bespoke skills. The proof layer has to span all of them. A platform-native cleanup tool covers its own surface; a cross-platform proof tool covers everyone’s. The latter is what enterprise procurement actually needs.

The third reason is the speed differential. The model labs ship features. The proof layer ships incidents-prevented. Different cadence, different failure mode, different team. Consolidation pressure exists, but the surface area for independent proof-layer vendors is large enough that two or three of them will be substantial businesses regardless of what the platforms do.

The Philosophy Braid: Jiro, Steve, MWP

The proof-layer thesis is not just a market call. It maps cleanly onto the three pieces of the philosophy I keep returning to.

The Jiro Quality Philosophy names the gate: quality claims require evidence, not feelings.¹⁸ The proof layer is the gate at the company-wide scale. Every Sonarly RCA, every Langfuse trace, every Charlie Labs daemon, every scar hook of mine is the same shape: evidence first, verdict second. Tools that bolt the verdict on top of unverified evidence get unwound the moment they cause a public incident.

The Steve Test is the gate one altitude up: would Blake sign his name to this?¹⁹ At an engineering-org scale, the question becomes: would the team sign their name to the agent’s output? That signature requires an audit trail, not a vibe. The proof layer is what produces the audit trail. Companies that ship without it are signing blank checks against future incidents, and the postmortems on those incidents will name the proof-layer gap as the root cause.

Minimum Worthy Product closes the frame.²⁰ Minimum is a scope constraint. Worthy is a quality bar. A minimum agent product is a generator. A minimum worthy agent product is a generator plus the proof layer that makes its output signable. Companies cutting the proof layer to ship faster are cutting worthy out of MWP. The market is correcting them in real time, which is why Charlie Labs pivoted, why InsightFinder raised, why Palo Alto Networks paid 3.35 billion for observability, and why my hook count compounds.

The cabinet metaphor from The Workbench I Carry extends straight into this market.²¹ The back of the cabinet is the part the customer never sees on a good day. It is also the part that fails publicly when somebody cut a corner where nobody was watching. The proof layer is the back of the cabinet. The companies whose back of the cabinet is finished win.

What This Changes For Operators

Three practical reads, ordered by impact.

Pick a proof-layer wedge before you pick a generation-layer agent. Most teams start with the agent and add observability later. Reverse the order. Pick the gates first (exit codes, schema validation, file-read audits, drift detection), wire them as one-directional dependencies, and only then add agents whose output flows through them. Generation that bypasses your gates is liability, not productivity.¹⁶²²

Treat scar-hook count as a leading indicator. If you are running agents and the cleanup count is not growing, you are not catching anything. The growth rate is the audit signal. My 47% in 26 days is not a brag; it is a measurement that the orchestrator is encountering new failure modes and recording them. Flat scar counts plus high agent activity is the danger zone.

Buy or build the proof layer cross-platform. When you evaluate proof-layer vendors, the right question is not “does this work with our model” but “does this work across every model and tool stack we will adopt in the next eighteen months.” Single-platform proof tools are the wrong shape. The category that wins is cross-platform.

What I Want Founders To Build Next

The proof-layer market is rich enough to support specialized verticals nobody has filled yet. I would pay money for:

• A reversibility-first deployment tool that scores every agent-generated PR by how cheaply the change can be unwound, before merging. High-cost reversals get blocked or routed to humans.
• A taxonomy-aware drift detector that maps each scar-hook category to specific test patterns and alerts when a category goes silent for too long. Silent categories are the dangerous ones.
• A regulator-ready audit trail product that takes any agent stack and produces a SOC 2-grade record of every tool call, every signature, every refusal. Regulated verticals will buy this before they buy more agents.

If you are building any of the above, you are building inside the proof layer. The market is moving toward you, not away.

The cleanup layer is the real AI agent market because generation is becoming a commodity inside the model APIs and proof is becoming the priced asset. Charlie Labs named it cleanest. The funded companies are racing into it. Generation expands the attack surface. Proof is the back of the cabinet. The companies whose back of the cabinet is finished win.

FAQ

Is “cleanup after agents” really a new market category?

The category is old. Cleanup spans SRE, QA, CI, code review, observability, security scanning, and incident response. What is new is the volume and the failure modes. Coding agents produce dozens of PRs a week per seat. Multi-agent architectures multiply that count. The four answer-shaped failure modes named in Reward the Tool Before the Answer are not what the existing CI stack was designed to catch. The category is old; the magnitude is what funds new vendors.

Why won’t Anthropic, OpenAI, or GitHub absorb the proof layer?

Three structural reasons. First, the artifact being evaluated must not help make the trust decision; model labs grading their own output is the in-house auditor problem. Second, real agent stacks combine multiple models, multiple tools, and bespoke skills, so the proof layer has to span all of them. Third, model labs ship features at one cadence; the proof layer ships incidents-prevented at another. Consolidation pressure is real but smaller than it looks.

What scar-hook patterns generalize beyond a personal orchestrator?

Four core gates: hedging-language detection on completion reports, exit-code checks on tool calls, file-read audits matching reports against the tool log, and narrative-drift detection between the original task and the summary. Each one is a one-directional gate: missing tool evidence blocks the answer’s score. The same shape works in production observability stacks; it just runs on different substrates.

How does the verification gap (69% of agent decisions need human review) close?

It closes by automating the gates that humans currently run by eye. Exit-code checks, schema validators, file-read audits, drift detection, and runtime guardrails are all examples of cheap deterministic supervision that move work out of the human queue. The 69% is a function of the proof tooling under it, not a fixed property of agents. Every gate that ships shrinks the percentage.

References