• 9 min read

AI Contributors: Lessons from GroeneAI and ClickHouse

tl;dr

Autonomous agents can rank among top open-source contributors, but only with mandatory human review gates and persistent trust infrastructure. GroeneAI merged 3,000+ pull requests for ClickHouse, ranking second behind the CTO while freeing engineers for higher-leverage work.

Featured image for "AI Contributors: Lessons from GroeneAI and ClickHouse"

ClickHouse’s autonomous agent GroeneAI has merged more than 3,000 pull requests since March 2026, ranking second among contributors behind only the CTO. That number forces a question every engineering leader should be asking: what happens when AI stops being a coding assistant and starts acting like a teammate?

What makes GroeneAI different from typical coding assistants?

Most AI coding tools wait for a human to assign a task. GroeneAI doesn’t. It selects work from CI failures, fuzzer findings, and user reports, then investigates, implements fixes, builds ClickHouse, runs tests, and opens pull requests — all without a human in the loop. The agent opened its first issue on March 25, 2026, and its first pull request followed 72 minutes later, according to ClickHouse’s engineering blog. Since then it hasn’t stopped.

The distinction matters because it shifts the bottleneck. Traditional assistants accelerate code generation. Autonomous contributors like GroeneAI shift the constraint to review judgment and trust infrastructure. The agent carries out the entire development process — selecting work, investigating causes, designing fixes, testing, and shepherding PRs through CI. Human involvement begins at review, where a maintainer decides whether to accept or redirect the change. CI fixes remain under verification for at least two days of subsequent master runs, per ClickHouse’s documentation.

This isn’t a demo. By October 2026, GroeneAI had contributed more than 3,000 merged pull requests to ClickHouse. Over the three months to October 19, it ranked second among contributors by authored non-merge commits, behind co-founder and CTO Alexey Milovidov, as reported in Milovidov’s LinkedIn post. GroeneAI and its sibling ClickGap hold the number two and three contributor spots, each with their own GitHub accounts. They act like teammates — responding to feedback, making friends with other contributors, and operating within the same social dynamics as human engineers.

How does the review-gated autonomy model work in practice?

The core tension in autonomous contribution is full autonomy versus mandatory human gate. GroeneAI carries out the entire development process without a human in the loop — it selects work, investigates, implements, tests, opens PRs, and monitors CI. No person chooses the steps. Yet every merge still requires a human maintainer to accept or redirect, making review the hard ceiling on throughput. This pattern — what I call review-gated autonomy — appears to be the only model that works at scale.

The workflow reveals why. GroeneAI monitors CI, answers review comments, revises implementations, and rebases changes as the repository moves. A task can stay active across many sessions, with investigation and next steps preserved throughout. When a June 2026 bug appeared in ClickHouse’s query-condition cache, the agent reproduced a failure involving pending data mutations, added a fix and tests, then addressed reviewer feedback. The change took 16 days from failed test to merge, with GroeneAI revising its pull request five times over 12 hours after initial review findings, as documented in ClickHouse’s case study.

That iteration speed — five revisions in 12 hours — is something human contributors rarely match. But the mandatory human gate means the agent can’t self-approve. Review comments trigger autonomous revisions, but the final decision stays human. This creates a natural rate limit: the team’s review capacity becomes the throughput ceiling, not the agent’s output volume.

AspectGroeneAIClickGapHuman Contributor
Primary focusCI failures, flaky tests, bugsMissing test coverageFeatures, architecture, complex bugs
Autonomy levelFull investigation to PRFull investigation to PRHuman-directed
Review gateMandatory human acceptanceMandatory human acceptancePeer review
Contributor rank (3 months to Oct 19)#2 by non-merge commits#3 by non-merge commits#1 (CTO Alexey Milovidov)
Merged PRs (since Mar 2026)3,000+Not disclosedVaries

The table above draws from ClickHouse’s blog and Milovidov’s LinkedIn post. Notice what’s missing: pricing. No per-seat, per-PR, or infrastructure costs for GroeneAI or ClickGap appear in any public source. The ByteJourney analysis notes that cost and computational resources for running such agents 24/7 are substantial but not discussed. An annual cost projection for a 50-developer enterprise team deploying GroeneAI-style autonomous contributors cannot be constructed from available research.

What infrastructure enables persistent memory and learning?

The agent’s greatest impact isn’t writing new features — it’s eliminating flaky tests and fatal errors, the unglamorous CI maintenance humans avoid. With AI adoption at ClickHouse, end-to-end product features in releases increased by 30%, bug fixes increased two and a half times, the ratio of flaky tests decreased ten times, and fatal errors were lowered by two orders of magnitude, according to Milovidov’s LinkedIn post. But those outcomes depend on infrastructure most teams don’t have.

GroeneAI saves root causes, failed approaches, and reviewer feedback in persistent memory and applies those lessons to later tasks across the SQL engine, storage, query planning, and test infrastructure, as described in ClickHouse’s engineering blog. That loop carried it from CI failures into correctness and performance problems across the codebase. The scope didn’t stay on CI for long.

This persistent memory is the differentiator. Without it, every session starts from zero. With it, reviewer feedback becomes cumulative rather than repetitive. The agent learns the codebase’s patterns — where guardrails are soft, which tests are flaky, how the query planner actually works. One engineer noted the agent exposed where guardrails were soft and forced them to become real. That’s a profound shift: the agent doesn’t just produce code; it reveals where your verification infrastructure is insufficient.

The runtime enabling this is Nerve, an open-source system providing persistent sessions, checkpoints, and separate planning, review, and implementation phases. Different models handle different phases — planning gets one model, implementation another, review a third. This phased workflow is well-architected, leveraging different AI models for specific tasks. But it also means you’re not dropping in a single API call. You’re building a runtime.

What are the measurable outcomes for ClickHouse?

The numbers are striking but need context. The 30% increase in end-to-end product features and 2.5x increase in bug fixes are outcomes, not direct agent output. They reflect a system where agents handle the maintenance burden — flaky tests down 10x, fatal errors down 100x — freeing human engineers for higher-leverage work. The agent’s 3,000+ merged PRs represent investigation and fixing work that would otherwise consume human hours.

But a merge count cannot tell us how much human effort each change saved or how many required substantial correction. The more persuasive evidence is the process: reproduce the bug, show the test fails without the fix, put a maintainer between the agent and the merge button. That’s autonomous work with a review trail, not a robot being handed the keys.

ClickHouse also built internal agents (DWAINE, CAISER, TRAISA) that teams interact with directly — an agent in the SQL console, an AI SRE. They use Claude Code to build and iterate on these agents themselves. The tooling powering their customers’ AI experiences is, in part, built with AI. Milovidov logged 10,111 sessions and 115 billion tokens in personal usage. That scale suggests the infrastructure investment is real and ongoing.

What should enterprise teams consider before adopting this model?

The contrarian take: teams should staff for review-gate design and guardrail infrastructure, not just code generation. The data shows agents can sustain autonomous contribution only when maintainer feedback is captured in persistent memory and enforced through CI, fuzzing, and a mandatory human merge gate. If your CI is flaky, your fuzzing is minimal, and your review process is rubber-stamp, an autonomous agent will amplify chaos.

Three tensions define the adoption decision:

Full autonomy versus mandatory human gate. GroeneAI operates without a human in the loop for investigation and implementation. But human involvement starts at review, and CI fixes remain under verification for at least two days of master runs. You need review capacity that scales with agent output.

Model capability as the unlock versus infrastructure as the unlock. Claude Opus 4.5 in November 2025 was the unlock — before it, the CTO was skeptical the model could handle the C++ codebase. After it, agents became daily work and top contributors. But effectiveness depends on persistent memory, checkpoints, separate planning and review phases, and CI/fuzzing guardrails. The model opened the door; the infrastructure keeps it open.

Agent as independent contributor versus agent as dependent on human judgment. GroeneAI and ClickGap are contributors #2 and #3 with their own GitHub accounts. Features increased 30% and bug fixes 2.5x. Yet agents cannot self-approve merges. Every pull request requires maintainer acceptance. Review comments trigger autonomous revisions but the final decision is human.

This mirrors what we’ve seen in repository context strategies for AI coding — enterprise AI cost is input tokens from agents re-exploring repos. The same principle applies: persistent memory and context infrastructure matter more than model tier.

How do the economics work for enterprise deployment?

Here’s the uncomfortable truth: we don’t know. No per-seat, per-PR, or infrastructure pricing for GroeneAI or ClickGap appears in any public source. The ByteJourney analysis explicitly notes that cost and computational resources for running such agents 24/7 are substantial but not discussed. An annual cost projection for a 50-developer enterprise team deploying GroeneAI-style autonomous contributors cannot be constructed from the research.

This shouldn’t surprise anyone who’s looked at AI coding stack economics for enterprises. Enterprise AI coding costs are driven by context, not model tier. But the infrastructure to run autonomous agents 24/7 — persistent sessions, checkpoint storage, multi-model routing, CI integration, fuzzing clusters — is a different cost category entirely.

What we can infer: the compute bill for 3,000+ merged PRs across seven months on a C++ codebase the size of ClickHouse is non-trivial. The agent builds the project, runs tests, monitors CI, and iterates. Each iteration consumes tokens. The persistent memory system stores and retrieves context across sessions. The separate planning, review, and implementation phases multiply model calls.

For teams evaluating this path, the question isn’t “what does the agent cost?” It’s “what does the infrastructure cost to make the agent trustworthy?” That includes CI reliability, fuzzing coverage, review bot sophistication, and the human review capacity to gate merges. The AI code ownership models discussion becomes relevant here — GitHub Copilot provides IP indemnity for enterprise AI code ownership protection, but autonomous agents operating under their own GitHub accounts raise new questions about liability and provenance.

Where does this leave your team?

If you’re leading an engineering organization, the GroeneAI case study offers a concrete existence proof: autonomous agents can be net-positive contributors in a complex, production-grade C++ codebase. But the enabling conditions are specific — persistent memory, phased workflows, robust CI/fuzzing, mandatory human gates, and a review culture that treats agent PRs with the same rigor as human ones.

The pattern isn’t “add AI agents.” It’s “build the trust infrastructure that lets agents operate autonomously within boundaries.” That’s a different investment thesis. It means staffing for guardrails, not just generation. It means treating CI reliability as a product requirement, not an operational afterthought. It means designing review processes that scale with agent output volume.

The open question: how many organizations have the CI maturity, fuzzing coverage, and review discipline to make this work? ClickHouse’s results suggest the payoff is real. The infrastructure investment required suggests the barrier to entry is higher than most vendors admit. Your move.