Can Cq (Mozilla AI) Stop Your AI Coding Agents From Making the Same Mistakes Over and Over?

Every AI coding agent you’ve ever used has the same dirty secret: it learns nothing from past sessions. Fire up Claude Code, Cursor, or any other agent, and it starts from zero — no memory of the bug it already fixed yesterday, no awareness that another agent on your team already figured out that one weird Stripe API quirk. Each session is a blank slate, and every blank slate costs you tokens, time, and patience.

Mozilla AI thinks this is a solvable problem. Their new project, Cq, is an attempt to build what they’re calling “Stack Overflow for agents” — a shared knowledge commons where AI coding agents can query past learnings, contribute new discoveries, and stop burning compute on problems that have already been solved.

The project hit Hacker News on March 24, 2026, pulling 141 points and 54 comments as a Show HN post. It’s still very much a proof of concept, but the timing couldn’t be more interesting: Andrew Ng asked the exact same question — “Should there be a Stack Overflow for AI coding agents?” — just weeks earlier, and his Context Hub project already has 10,000+ GitHub stars. The race to build shared agent memory is on.

The Problem: Isolated Agents, Duplicated Mistakes

Here’s a scenario that plays out thousands of times a day across dev teams worldwide. An AI agent is tasked with integrating a payment API. It reads the docs, writes some code, hits a weird edge case (say, the API returns a 200 status code with an error body for rate-limited requests), burns through several rounds of debugging, and eventually figures it out. Session ends. Knowledge gone.

The next day, a different developer on the same team asks their agent to do the same integration. Same wall. Same debugging loop. Same token burn. Multiply this across every developer, every agent, every codebase, and you start to see the scale of waste.

This isn’t a hypothetical. Anyone who’s worked extensively with AI coding agents knows the pattern. Agents don’t share context across sessions or users. They can’t tap into what other agents have already learned. Every agent is, effectively, an amnesiac contractor who shows up each morning having forgotten everything from the day before.

How Cq Works: Knowledge Units and Trust Signals

Cq’s core concept is the Knowledge Unit (KU) — a structured piece of information that an agent proposes based on gotchas, patterns, or insights it encounters during a coding session. Think of a KU as a concise, machine-readable lesson learned: “Stripe’s API returns HTTP 200 with an error body when rate-limited — check the response body, not just the status code.”

The workflow looks like this:

Query before coding. Before an agent tackles unfamiliar work — an API integration, a CI/CD config, a framework it hasn’t touched — it queries the Cq commons. If another agent has already learned something relevant, that knowledge is available immediately.
Propose after learning. When an agent discovers something novel during a session, it proposes that knowledge back to the commons as a new KU.
Verify through use. Other agents can confirm what works and flag what’s gone stale. Knowledge earns trust through actual use, not through authority or upvotes alone.

What makes this more than just a shared notepad is the trust layer. Cq has built-in confidence scoring, reputation tracking, and trust signals. Knowledge that’s been confirmed by multiple agents across multiple codebases carries more weight than a single model’s best guess. The more agents that participate, the better the quality signal becomes.

The implementation ships with several components: a plugin for Claude Code and OpenCode, an MCP server that manages your local knowledge store, a team API for sharing knowledge across your organization, a UI for human-in-the-loop review, and containers to spin the whole thing up. If you’re already working with MCP-based tools for AI coding, the architecture will feel familiar.

The Andrew Ng Connection

Cq didn’t emerge in a vacuum. Mozilla AI started building it in early March 2026, and shortly after, Andrew Ng posted a question that validated the entire thesis: “Should there be a Stack Overflow for AI coding agents to share learnings with each other?”

Ng wasn’t just asking rhetorically. He’d already launched Context Hub (chub), an open-source CLI tool that gives coding agents access to curated, up-to-date API documentation. Context Hub hit 10,000 GitHub stars in its first week and scaled from under 100 to over 1,000 API documents through community contributions. It also includes a feedback mechanism where agents can vote on documentation accuracy, creating a crowdsourced quality signal.

But Context Hub and Cq are solving overlapping but distinct problems. Context Hub is primarily about documentation — making sure agents have access to correct, current API docs instead of hallucinating outdated ones. Cq is about experiential knowledge — the gotchas, edge cases, and practical patterns that agents discover through actual coding work. Think of it this way: Context Hub tells your agent what the API docs say, while Cq tells your agent what actually happens when you use the API in the real world.

The name “Cq” itself nods to this broader vision. It’s derived from “colloquy” (a structured exchange of ideas) and from the ham radio term “CQ” — a general call meaning “any station, respond.” It’s an invitation for agents to share what they know.

Cq vs. the Competition: Who Else Is Building Agent Memory?

Cq isn’t the only project trying to solve agent amnesia. The space is heating up fast:

Andrew Ng’s Context Hub — The most prominent competitor by star count (10K+ on GitHub). Focuses on curated API documentation with two content types: Docs (“what to know” — large, ephemeral, fetched per-task) and Skills (“how to do it” — small, persistent, installed into agent skill directories). Its feedback system lets agents vote docs up or down to surface the most reliable resources over time.

Context Overflow — A Q&A knowledge-sharing app at ctxoverflow.dev where agents can ask questions when stuck and publish solutions they discover. It sits somewhere between Stack Overflow and a vector database, with agents contributing and consuming structured context automatically. Works with any agent framework.

MoltyOverflow — Another entrant in the “Stack Overflow for agents” race, though with less community traction so far.

Where Cq differentiates itself is in the trust and reputation layer. Context Hub’s quality signal comes from binary up/down votes on documentation. Cq aims for something more sophisticated — confidence scores that evolve as knowledge gets verified across multiple agents and codebases. Knowledge isn’t just “popular”; it’s “battle-tested.”

The Mozilla AI brand also carries weight here. Mozilla has a long track record of building open, community-driven tools (Firefox, MDN Web Docs), and Cq fits into their broader AI ecosystem that includes any-agent (a unified interface for different agent frameworks), any-llm, any-guardrail, and mcpd. If you’re building with multi-agent orchestration frameworks, the interoperability story matters.

What the Community Is Saying

The Hacker News discussion around Cq’s Show HN post has been generally positive but cautious. The core reaction: the problem is real, but execution at scale is going to be the hard part.

Several commenters noted the potential for Cq to become an “information gateway for all public agentic learnings” — essentially the canonical source of agent-generated knowledge. Some speculated about eventual acquisition by GitHub or Stack Overflow. Others raised practical questions about knowledge quality control: how do you prevent bad or outdated KUs from polluting the commons? How do you handle conflicting knowledge from different agents on different models?

These are legitimate concerns, and Mozilla AI acknowledges the project is still very much a proof of concept. The roadmap goes from local use (a single developer’s agents sharing knowledge with each other) to team-level sharing (agents across an org) to, eventually, a public commons. Each level introduces new challenges around trust, curation, and noise.

The fact that this is a PoC is worth emphasizing. You can install it and try it today, but don’t expect a polished, production-ready system. This is more of a working thesis than a finished product — Mozilla AI is iterating in public and inviting the community to shape what it becomes.

Why This Matters Beyond the Hype

The broader trend here is significant. As AI coding agents become the default way developers interact with codebases — and tools like knowledge graphs for code review continue to mature — the question of agent memory becomes unavoidable. Right now, every agent session is a one-off consultation. The industry is moving toward agents that accumulate institutional knowledge over time.

Cq’s bet is that this knowledge should be shared, open, and community-governed — not locked inside proprietary systems. Whether Mozilla AI can execute on that vision at scale remains to be seen, but the question they’re asking is the right one.

FAQ

Is Cq (Mozilla AI) free and open source?
Yes. Cq is open source and free to use. It follows Mozilla AI’s philosophy of building transparent, community-driven AI tools. You can self-host the entire stack using the provided containers.

What AI coding agents does Cq support?
Cq currently has plugins for Claude Code and OpenCode, plus an MCP server that can theoretically work with any agent that supports the Model Context Protocol. The architecture is designed to be agent-agnostic — any agent, any model.

How is Cq different from Andrew Ng’s Context Hub?
Context Hub focuses on curated API documentation — making sure agents have correct, current docs. Cq focuses on experiential knowledge — the practical gotchas and patterns agents discover through actual coding. Context Hub tells your agent what the docs say; Cq tells your agent what actually happens in practice. They’re complementary rather than directly competing.

Is Cq ready for production use?
Not yet. Mozilla AI explicitly describes it as a proof of concept. It works for local and small-team use cases, but the team is still iterating on the trust, reputation, and scaling mechanisms needed for broader deployment. Think of it as an early-access experiment.

What does “Knowledge Unit” mean in Cq?
A Knowledge Unit (KU) is Cq’s standard schema for a piece of agent-learned knowledge. It’s a structured, machine-readable insight — like an edge case, a workaround, or a pattern — that an agent discovered during a coding session and proposed back to the commons for other agents to use and verify.

Top AI Product

Leave a comment Cancel reply