Future AGI Q2 2026: Fully Open Source Under Apache 2.0

The quarter we opened the whole platform, from tracing to the gateway, and watched the community start building on top of it.

In Q2 2026, Future AGI went fully open source under Apache 2.0. The whole platform, tracing, evaluations, simulations, datasets, observability, guardrails, and the gateway, is now open to read, extend, and self-host. We did it because the teams betting on us in production deserve to see exactly how their tooling works.

This recap walks through what that decision changed, what we shipped, who built it with us, what we learned running at scale, and where Q3 is headed. No announcement theatre, just the quarter as it happened.

Opening the entire platform under Apache 2.0

The biggest change this quarter was a decision, not a feature. We opened every layer of the platform, so you can read exactly how an evaluation is scored, fork the piece you need, and run the same system we run on your own infrastructure. For a team that has to trust its tooling in production, or keep sensitive traces in-house, reading the internals matters more than any single capability.

Apache 2.0 keeps it permissive: use it commercially, modify it, ship it, no strings on the license. Since we opened the repo the numbers have moved fast, and the stars are exciting, but the pull requests are even better. Each one is someone reading the code and making it sharper, and we have had more of those than we expected.

These numbers move every day, so the honest thing to say is simple: come see for yourself. Star the repo if it is useful to you, fork the part you want to change, or clone it and run the whole platform locally from GitHub.

Three launches that defined Q2

Three launches shaped the quarter: Error Feed reached general availability, the Agent Command Center went live, and our evaluation stack got a lot deeper. Each had been in the works for a while, and each one is now something you can run yourself.

Error Feed reaches general availability

Error Feed reads your production traces, groups recurring failures into ranked issues, shows real examples, points to the likely root cause, and recommends what to fix. Instead of combing hundreds of traces to find the three problems actually hurting an agent (a tool call that times out, a retrieval step returning the wrong document), your team opens Error Feed and sees them ranked. It works on both text and voice agents.

The Agent Command Center goes live

The Agent Command Center is one endpoint for 100+ model providers, with routing, caching, fallbacks, cost controls, observability, and inline guardrails. Switching a model or adding a fallback becomes a config change, not a rewrite across your codebase.

On a single instance it benchmarked at about 29K requests per second with a P99 of 21ms, and the benchmark is public so you can reproduce it. A gateway should stay out of the way of your agent, not become its slowest hop, and that number is how we hold ourselves to it.

A deeper evaluation stack, wired into your traces

We kept expanding the open-source evaluation SDK and the platform’s evaluation workflows: more built-in evaluators, custom evals you write yourself, and richer CI/CD support. The bigger shift is connecting evals directly to traces.

That means a check runs inside the shipping loop, so a failing one can block a release instead of surfacing weeks later in a postmortem. You write the grading rule, pick an LLM judge or a deterministic check, point it at the traces or dataset columns you care about, and run it as a CI gate.

For example, you can block a release when accuracy on a golden dataset slips below your bar, or when an answer fails a groundedness check you defined. The rule is yours, and the platform runs it every time you ship.

More integrations, less glue code

This quarter we added support for Mastra v1, A2A, and MiniMax, and updated Google ADK, on top of an ecosystem that now spans 45+ frameworks, providers, and vector stores. These are the connectors teams kept asking for as their agent stacks grew more mixed.

The names most teams already run are in there: LangChain, LlamaIndex, CrewAI, Haystack, LiveKit, Pipecat, Anthropic, OpenAI, Gemini, Mistral, Groq, Pinecone, Qdrant, and Weaviate among them. You should not have to rewrite your stack just to adopt ours, and the best integration is the one you forget is there because it works.

A backend rebuilt for billions of traces

The least glamorous project of the quarter was also one of the most important. As trace volume moved into the billions, we migrated more of our backend to ClickHouse. That is a good problem to have, and still a real problem to solve.

Migrations look clean on a whiteboard and messy in production, but the outcome was worth it. Future AGI is now built for the trace volume we see today, and the much larger volume we expect next. That work never shows up in a changelog, and it is exactly what keeps everything above it dependable.

Built by the community and the team

A lot of this quarter came from outside the core team, through open-source contributors and thousands of conversations at workshops. Three contributors stood out, and their work is the kind you feel every day.

@ZhangShenao made tags editable right from the trace list, turning a multi-screen detour into a two-click job. It was the single biggest community improvement of the quarter, and anyone who lives in their traces will notice it.

@Priya-raja proposed, built, and shipped a new way to score answers by how they sound, alongside how they are spelled, and flagged a related bug on the way through.

@aaronjmars tidied up a few rough edges in the platform’s security in one clean, careful change that protects everyone using Future AGI.

We ran five workshops across the US and India, with 2,000+ registrations and 800+ live attendees. Every session drifted to the same question: how do you make an agent reliable after it ships? Those conversations shaped our roadmap more than any planning meeting did.

Going open source also changed how we work. An internal shortcut is invisible until someone outside the team hits it, and untangling years of those decisions is what let people self-host the same platform we run every day. Kartik, Khushal, Rishav, Atharva, Jaya, Azain, Karthik, Sarthak, Dileep, Salil, Vrinda, Chintan, and many more made that happen.

What comes next in Q3?

Q3 builds straight on the open-source foundation. Three things we are focused on:

• A deeper simulation stack: more provider integrations (LiveKit, Bland, ElevenLabs, Glean, and more), simulation for CUA and coding agents, and better tool-call mocking grounded in real incidents.
• A more capable agent playground: replicate an end-to-end agent on the platform for simulation and experimentation, with nodes like API calls, evaluations, tool-call mocking, branching logic, and loops.
• A friendlier path from prototype to production: prototyping is developer-first today, and we are making it UI-friendly too, with a common starting point for experiments.

The part we are proudest of

Q2 was the quarter Future AGI opened up. Most of what made the platform better came from people outside our team reading the code, filing pull requests, and telling us where it hurt, in public. That is the same invitation we are carrying into Q3.

The whole platform is on GitHub under Apache 2.0, free to read, fork, and self-host. Read the documentation, see what we are building at futureagi.com, or start in the Future AGI app and tell us what to make next.