Open sourcing Polaris

Build harnesses for powerful, reliable agents.

Radiant Labs

Purple wave artwork

Today we're releasing Polaris in alpha — our open-source framework for building multi-agent AI systems. It's early, it will change, and we're sharing it now because we believe the best way to build infrastructure is in the open.

The bottleneck in AI agents isn't the LLM. It's finding the right design for your needs.

Every agent framework gives you the same thing: a fixed loop. Reason → Act → Observe → Repeat. Maybe with some tools bolted on. Maybe with some memory. But always the same loop.

And when that loop doesn't work for your use case? Or when your problems are so different that you need to rethink how the agent's memory works altogether? You're rewriting the framework.

The Problem with Fixed Agent Frameworks

Many agentic frameworks - and even open-sourced AI agents - come with a set of opinions on "how" an AI agent should function. You'll often find agentic loops and logic hard-wired into the heart of the framework. Especially if you're just beginning to build your own agents, here's what happens:

  1. You start with their default ReAct loop (reason → act → observe → repeat)
  2. It works for demos
  3. Your real use case needs something different
  4. You fight the framework
  5. You fork it or abandon it

The framework authors made design decisions. Those decisions are now your constraints.

Agents Are Designs, Not Imperative Code

Most frameworks bury agent logic underneath the hood. A while True loop somewhere. A hardcoded sequence of LLM calls. Control flow scattered across methods and callbacks.

But look at the highest-performing agents in the wild—Claude Code, OpenClaw, Devin—each has its own unique logical design. Their power comes not from better prompts, but from better architecture. Different patterns for different problems.

When you view agent logic as imperative code, changes are painful. When you view it as a design to be explored, iteration becomes natural. The question shifts from "how do I implement this?" to "what flow achieves the behavior I want?"

In Polaris, that design is explicit. An agent is a graph—nodes are computations, edges are control flow. The structure is the logic. You can see it, change it, and swap it entirely, or even just swap out parts of it.

Composition Over Inheritance

Traditional frameworks extend base classes. Override methods. Configure options. You're always building on top of someone else's assumptions.

Polaris inverts this. Behaviours are composed from primitives—a reasoning node here, a conditional branch there, a parallel execution block when you need it. Want to add validation before tool calls? Insert a node. Want to try a completely different pattern? Swap the graph. No refactoring required.

Capabilities work the same way. Tools, memory systems, LLM providers—they're all plugins that compose together. Use simple conversation memory for prototyping, upgrade to semantic retrieval when you're ready. The architecture doesn't care.

Why this matters

This matters because the agent landscape is evolving fast. Last month's best practice is this month's anti-pattern. The teams that win will be the ones that can iterate fastest on agent design.

You can't iterate fast if you're fighting your framework. You can't experiment if changing the loop means rewriting the core. You can't discover novel patterns if you're locked into someone else's assumptions.

Polaris gives you building blocks, not blueprints. The design is yours to discover.

Alpha, not finished

Polaris is in alpha. The API will change. There are rough edges. We're releasing it now because we think the ideas matter more than polish, and we want to build in the open with the community.

If you're interested in shaping how agent infrastructure evolves, we'd love your input — try it out, open issues, and tell us what's missing. You can find us on GitHub or reach us at [email protected].