The Animus Project

Intelligence that stays home.

Cloud agents are remarkable — and for a lot of real work, they're not an option. Air-gapped environments, proprietary code, regulated data, edge devices. Animus is an open-source agentic coding harness built for small local models (1B–14B GGUF): the models you can actually run on a workstation, a home lab, or a Jetson board on your desk.

Ferric on GitHub Commission an implementation

The lineage

Four implementations to get it right.

Animus wasn't designed in one sitting — it was earned. Three earlier implementations are dormant in public repos, and each one taught us something the next one kept. That history is the feature: every conviction in Ferric was paid for with working code.

  1. Python

    Animus

    The original prototype: an open-source, natively running agentic CLI. It proved the demand — and taught us that a harness gluing together a dynamic runtime leaves too much of the agent's behavior to chance.

  2. Go

    Animus Prion

    The rebuild for speed and static binaries. Prion sharpened the tool-calling loop and showed how much discipline small models need from the harness around them.

  3. Go

    fev

    A local-first assistant for navigating the digital space. fev explored the personal-agent side of the problem and clarified what belongs in the harness versus the model.

  4. Rust Active

    Animus Ferric

    The Rust synthesis of everything the lineage learned. Ferric is where the project found real traction: a harness that owns decoding, scales its behavior to the model, and treats the trajectory as the source of truth.

The convictions

Three rules, paid for in working code.

01

The harness owns decoding

Constrained generation — JSON-Schema, regex, and CFG grammars — is driven end-to-end in the agent loop. Malformed tool calls are impossible, not merely repairable. Small models don't get to improvise the protocol.

02

Behavior scales to the model, deterministically

A pure function maps a model profile — parameters, quantization, context, measured capability — to a run policy: protocol, plan granularity, turn budgets, tool count. A 3B model gets 3B-sized steps. No guesswork, no vibes.

03

The trajectory is the source of truth

Every session writes a versioned JSONL trace — full conversation, tool calls, untruncated output, execution chain — replayable and diffable. If it isn't in the trace, it didn't happen.

The commission

Open source project. Paid implementations.

Ferric is MIT-licensed and free forever. What I sell is the last mile: making local agents work on your hardware, against your codebase, inside your security boundary.

Custom harness implementations

Ferric (or a purpose-built harness) adapted to your environment: your tool surface, your permission model, your models. Constrained decoding tuned to the workflows your team actually runs.

Edge AI deployments

llama.cpp servers with custom harnesses on workstations, on-prem servers, and Jetson-class edge devices. Commercial deployments delivered — model selection, quantization, serving, and the agent loop on top.

Local-agent strategy

Not sure whether a 7B model on your hardware can carry your workload? Ferric ships a capability ladder (L0–L6) for measuring exactly that. I'll benchmark it and give you a straight answer before you spend.

Commission a build

Or email charles@threadandsignal.com with a sketch of your environment.