On this page
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.
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.
| Aspect | GroeneAI | ClickGap | Human Contributor |
|---|---|---|---|
| Primary focus | CI failures, flaky tests, bugs | Missing test coverage | Features, architecture, complex bugs |
| Autonomy level | Full investigation to PR | Full investigation to PR | Human-directed |
| Review gate | Mandatory human acceptance | Mandatory human acceptance | Peer 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 disclosed | Varies |
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.
Recommended Reading
-
Best Open Source Autonomous Coding Agents in 2026 Compared
Claude Code leads the harness comparison at 55.4% on SWE-bench Pro, beating the standardized scaffold at 45.9%. The same model produces materially different results depending on the wrapper, so the control surface matters more than the model itself.
-
1,652 Merged PRs: Claude Code Fleet and Agentic Productivity
Agent fleets shift the delivery bottleneck from writing code to human review, CI throughput, and source control infrastructure. A single developer directing Claude Code agents produced monthly pull request volume comparable to major open-source repositories.
-
DeepSeek dsh-Superagent vs Claude Code: Open vs Junior Devs?
Claude Code wins for production teams needing managed approval workflows and predictable $20 per month pricing. DeepSeek dsh-superagent is an open research prototype whose router-worker architecture hit 15.7 minutes p95 completion versus 29.5 minutes baseline, but it runs shell commands as your OS user without approval prompts.