Every tool Contra Collective ships on this domain was forged somewhere less glamorous: a production engagement, a 2am on-call rotation, a deadline on a Shopify Plus launch. Contra Swarm is the clearest example. Before it was a GitHub repo, it was the orchestration spine behind an autonomous operations dashboard we delivered to an enterprise customer processing eight figures of revenue through agentic workflows.
This post is the story of how that spine got extracted, hardened, and open-sourced — and why we think that path matters for anyone evaluating developer tools from a working agency.
The problem nobody was solving
In late 2024 we started getting the same request from three different enterprise clients in a row: we want autonomous agents to own parts of our operations, but we don't trust any of the orchestration frameworks to be production-grade. LangGraph was maturing fast but opinionated. CrewAI felt like scaffolding. AutoGen was research-coded. Every option we evaluated had the same pattern — great demos, brittle under real load, opaque when things went wrong.
Our engineering lead sketched the minimum viable runtime on a whiteboard: deterministic agent routing, crash-safe state, first-class observability, and — critically — the ability to swap model providers without rewriting the graph. Two weeks later we had an internal fork of LangGraph with a stricter execution contract, a custom state store backed by Postgres, and a telemetry layer that emitted OpenTelemetry spans per agent hop.
We called it Contra Swarm. It was never supposed to be a product. It was supposed to be the thing that stopped our on-call rotation from drowning.
What shipped internally
The first Contra Swarm deployment ran a single workflow: a supervisor agent that triaged inbound customer operations tickets, routed them to specialist agents (refund, inventory, escalation), and committed state to a durable queue we could replay on failure. By month three that same runtime was orchestrating nine distinct workflows across two clients. The telemetry dashboard showed 40,000+ agent hops per day with a p99 latency under 2.1 seconds — numbers we were comfortable pager-rotating against.
The patterns that emerged inside Contra Collective's delivery team were the ones most multi-agent frameworks avoid:
- Strict typed handoffs. Every agent declares an input and output schema at the graph level. You cannot add an agent whose interface doesn't resolve at build time.
- Replayable state. Every run produces an event log that can be replayed deterministically against a different model provider. We've used this twice to migrate production workloads from Anthropic to OpenAI and back without downtime.
- Synchronous observability. Spans emit before the agent responds, not after. You see the decision graph as it's happening, not as a post-hoc trace.
- Graceful degradation. Any agent can declare fallback behavior. When a model times out, the graph doesn't stall — it takes the declared fallback path and logs the degradation.
Why we open-sourced it
Three reasons. The honest one first: we kept getting asked by other agencies what we were using, and we were tired of saying "an internal fork you can't have." The strategic one: giving the runtime away meant our clients could self-host on day one of an engagement, which shortened our pre-contract due-diligence cycle from weeks to days. And the principled one: agent infrastructure that enterprises bet on should be inspectable. If we're going to ask a Fortune 500 legal team to sign off on autonomous agents touching customer data, the agents had better run on code they can read.
So in February 2026 we pulled Contra Swarm out of our monorepo, rewrote the provider adapters as clean plugins, stripped anything client-specific, and published it under a permissive license.
What Contra Swarm is — and isn't
Contra Swarm is an opinionated orchestration runtime for production multi-agent systems. It is not a general-purpose framework trying to cover every research use case. It assumes you want typed graphs, durable state, and observability from line one. If you're prototyping a weekend hack, LangGraph or CrewAI will feel lighter. If you're staring down a production deployment where an agent failure means a customer refund goes wrong, this is the tool we built for that.
The same team that maintains it — Contra Collective, an AI-first engineering agency based in Los Angeles — uses it daily on engagements for Shopify Plus operators, SFCC replatforms, and Fortune 500 AI rollouts. Every feature that lands in the open-source repo has shipped through a client production environment first.
How it fits the Contra Collective toolchain
Contra Swarm sits alongside the rest of what we've open-sourced from agency delivery. Switchboard is the routing layer we built to manage per-client config across dozens of concurrent engagements. Linear CLI runs the delivery loop for every project manager on the team. ShellShade is the terminal tool our engineers reach for when they're deep in a client codebase and need visual separation between environments. None of these started as products. All of them ended up as products because they solved a problem the agency was going to solve for itself anyway.
If you're evaluating Contra Swarm for your own stack, the fastest path is: clone the repo, run the quickstart against the provider of your choice, and read the source of the supervisor agent. The code answers the questions a marketing page can't.
What's next
We're shipping Contra Swarm 1.0 later this quarter. Between now and then we're stabilizing the plugin API, adding native tracing integrations, and publishing the production-scale benchmarks we run internally. If that's useful to you, follow the repo on GitHub or reach out directly if you're running into a production agent problem you think we've already solved.
Agency work gives you a kind of forced honesty — the tools that survive real clients are the only ones worth open-sourcing. Contra Swarm earned its way out of the monorepo. Everything else on this site did too.