From AI That Writes Code to an Agent You Trust

In five weeks of working with Anantys, the engineering team at ArtMajeur (an online art marketplace) got past the review bottleneck every AI-heavy team eventually hits, and onboarded an autonomous agent that reviews, writes, and investigates across their whole stack, on its own schedule. Here's how it went.

Stéphane Lévy, ArtMajeur We knew about Koan, but we had our doubts. Not reading every line of code ourselves felt out of the question. Alexis, Anantys' CEO, taught us to step back, to trust Koan as an autonomous development agent, and finally to run human review in "macro mode".

Once you adopt AI, you hit the review wall

By the time we started, in mid-June 2026, the ArtMajeur engineers were already writing code with AI every day. And they'd already run into the classic problem: code gets written faster than anyone can read it.

With models like Anthropic's Opus, generating solid, reliable code is basically a commodity now. But does near-free code translate into a real productivity win, from spec to production? Of course not. That would be too easy.

Any team living with AI day to day knows what actually happens: the bottleneck just moves. The code comes out fast, it's mostly good, but somebody still has to understand it, review it, and keep the team's mental model of the system intact. Change nothing else about how you work and you end up drowning in open pull requests. Read every line yourself and you've thrown away most of what the AI just gave you.

Maxime Navoizat, ArtMajeur I felt like I had to read all of it, and it wore me down. I was spinning my wheels, going in circles.

So generating code is only step one. To really multiply what a team can ship, you have to rethink the whole pipeline. And the first thing in the way is how much you trust the code in front of you: how do you raise that trust without giving up an inch on reliability, and rebuild the PR / review / merge loop around it?

That's why the work came down to two things:

1. Harden the test infrastructure (CI, environments, impact-based test selection) so patches get verified automatically wherever that's possible. Whatever the machine checks, a human doesn't have to.
2. Get the team comfortable with kōan, an autonomous development agent that lives inside GitHub, and shift the daily rhythm: hand most of the work to the agent, keep the human in the loop. That's the whole idea behind kōan.

Kōan, plugged into the real thing

Kōan, our autonomous coding agent, gets configured for whatever ArtMajeur actually needs: custom skills, and recurring tasks that let it act on its own. More importantly, we give it eyes, by wiring it into their environment through a handful of MCP servers, all read-only:

• The real databases, so it can query production-grade data, dig into the data model properly, and make proposals that hold up;
• Grafana for logs and business metrics, so it can watch production bugs, slowdowns, and attack patterns without being asked;
• Cloudflare for inbound traffic, so bot attacks get caught upstream and a GitHub issue opens the moment something serious fires;
• Playwright to drive a browser, so it can actually look at what it built.

Earn the trust, then delegate

The first piece has nothing to do with AI. It's about the environment the AI runs in: a real automated test suite, run on every change, with a coverage floor enforced in CI. That safety net, plus the feedback the agent gets from its own access (it can see what it's doing), is what lets the team stop reading every diff in detail on the work it trusts. The velocity you were losing in review comes back.

Semi-automated review, where it clicked

If review is the bottleneck because AI writes too fast, then point the AI at the bottleneck too.

On every pull request, kōan posts a full review as a GitHub comment: a verdict up top (mergeable or not), what's good about the patch, the problems ranked by severity, and a checklist of everything it actually checked.

Here's what makes the difference: it doesn't just read the diff. The agent runs in a sandbox with the full git clone, so it can verify every claim it makes against the entire codebase, not just the lines that changed. That's why its reviews hold up.

The human reviewer isn't staring at a wall of diff anymore. They're looking at a prepared case with a recommendation to accept or push back on. That's exactly what Stéphane means by running review in "macro mode".

GitHub turns into the place where the whole team meets, agent included. No more babysitting: nobody watches a screen while the LLM thinks, nobody repeats the same review instructions, nobody writes their own version of review, implement, rebase, or fix.

Kōan's repo is public, so you can check for yourself. Browse the PRs, the issues, or read the review on PR #2454 end to end.

Going further: an agent that speaks first

The last few sessions went after something more ambitious: a two-way relationship. The agent should flag problems on its own, and open an issue or start building a fix when it decides that's the right call.

Maxime Navoizat, ArtMajeur It's like we spun up an SRE team from scratch on the monitoring side, one that never looks away. Now you've got eyes on your back. You catch problems fast.

We set that up with kōan's recurring tasks: custom skills that fire on whatever schedule you pick, and they're especially good at digging through production data via the MCP servers already in place. Two real examples from ArtMajeur.

The daily production bug sweep. Every day, kōan pulls logs and metrics through the Grafana MCP, spots errors that keep coming back, narrows down the likely cause, and opens a GitHub issue with a diagnosis and a fix plan already written up. Bugs surface before users report them. From there the team just mentions the agent to get an implementation, and a pull request shows up a few minutes later. GitHub effectively becomes the team's IDE.

Attack and bot detection. Same idea, different data: kōan reads traffic through the Cloudflare MCP, picks out the patterns that don't belong (scrapers, API abuse, bot campaigns), and opens an issue with ranked recommendations like rate limits or WAF rules. What the team ends up with is a scrappy SIEM for a fraction of the price: the kind of security coverage a much larger company pays a dedicated team for.

Two more watchers run the same way: performance regressions, and support tickets grouped by root cause. And this part matters: nothing ever ships without a human signing off.

Getting AI right is bigger than picking a tool

Adopting Claude Code, Codex, or Cursor isn't the finish line. To actually clear the bar and unlock what your team can do, you have to rethink the whole flow, from spec to production, review and sign-off and log watching included. All of it reorganizes around a new player everyone has to get used to: the autonomous development agent.

Stéphane Lévy, ArtMajeur Now that everything is set up and configured, we're starting to see the payoff: costs under control, better and broader test coverage, bugs fixed without pulling in the devs, QA handled, and Product shipping on its own for anything that isn't complex. Koan is so deep in our daily work at this point that going back isn't something we'd consider.

---

This project is part of Anantys' AI Coding practice. Want to help your engineers get everything they can out of AI, or run kōan inside your own infrastructure? Get in touch