Not a copy.
An extension of you.

A unified interface across roughly 30 providers means swapping models without touching agent logic — but modularity that only adds providers adds token overhead too, because every tool definition gets stuffed into every request. A relevance gate filters tool definitions down to what actually matters per request, cutting token usage on that path by roughly 53%. The framework scales as you add tools instead of choking on its own surface area.

Built to be built on, not just used as-is. "I want to talk to you through Zalo" becomes a new transport module, not a fork. The same holds for attaching Blender, a design system, or whatever surface you need — the core engine stays put and you add a door rather than rebuilding the house.

An agent framework is a plugin ecosystem in disguise — providers, tools and transports all growing over time. TypeScript keeps that honest as it scales, and lets the same core ship to very different surfaces from one codebase: a full terminal UI with vim-style modal editing for developers, and aura-droid, a WebSocket client putting the same engine behind a lighter, consumer-facing surface.

There isn't one memory, there are layers: a hard session token budget that resets cleanly across commands, working context for the active task, and an end-of-session memory-writing pass that distils what mattered so the next session doesn't start cold. Closer to how a person actually remembers a project.

Most frameworks run a single tool-heavy loop built for coding. aura-code has two, switchable mid-session. The coding loop gets full tool access and deliberate pacing for real engineering work. The gazelle loop is a lean personal-assistant mode — near-zero tools, a roughly 990-character system prompt, dramatically lower token cost per turn. Not the coding agent in a friendlier hat: a structurally different loop for structurally different work.

Every request routes to a small local model first, and the answer passes a confirmation layer before it reaches you. Factual claims are checked strictly against tool evidence — wrong is wrong. Proposals are judged differently: does it address the task, is it coherent, does it understand current state, does it acknowledge tradeoffs. Any fact embedded in a proposal is still checked strictly, so nothing gets smuggled past the verifier dressed up as an opinion. Pass and it's done locally and cheaply; fail and it escalates to the large cloud model. The routing is by actual outcome, not by task type.

Every failed verification is automatically a labelled training example — a case where the small model was wrong and the large model was right. That collected-mistakes data was used to fine-tune the small local model, then validated against the 320-question Aura Benchmark: one baseline pass before fine-tuning, one after, the same questions. The fine-tuned pass showed a clear improvement in first-pass accuracy — fewer escalations for the same quality of answer.

All of it is backed by 1,559 passing tests and the Aura Benchmark suite of 320 questions. The design claims above are the ones the test suite and the benchmark actually hold to.