A
axobrier v0.2.0
Why Local Hardware How It Works Compare vs Jev Integrations Tech Specs Star on GitHub
Open-Source • Apache 2.0 • Local C/CUDA Inference

Stop Paying a Cloud Toll Just to Make a Decision.

A completely free, open-source System 1 decision engine that runs locally on your machine in 40 microseconds—not over the cloud. Works on standard laptops, headless CI runners, or dedicated GPUs.

Download Windows x64 Release Star on GitHub

Full C/CUDA source code open under Apache 2.0. Pre-compiled binaries provided for 1-click Windows x64 execution without needing CUDA toolchain setup.

The Origin Story

We built Axobrier internally to eliminate the multi-second delay in autonomous developer loops. With the sudden popularity of paid cloud decision models like Jev charging per-token tolls, we decided it was time to open-source our engine to the public under Apache 2.0. Zero cost. Zero cloud dependency.

Local Metal Architecture

Why Local Beats Cloud

Routing a closed-set decision should be as fast as a CPU instruction, not a transcontinental network packet.

$0.00 / call

$0.00 Forever (No API Keys, No Subscriptions)

Run millions of triage and tool-selection decisions without watching an API billing meter tick up. No rate limits, no credit cards, and no unexpected cloud invoices.

40 µs vs 300 ms

Microsecond Speed (40 µs vs 300 ms)

Cloud decision APIs force you to wait for a 200–500ms network round-trip. Axobrier executes right on your GPU or CPU before the network packet would even leave your computer.

100% Air-gapped

Total Data Privacy

Your compiler logs, source diffs, and agent tasks stay on your local metal. Fully air-gapped and safe from remote data retention, leaks, or training telemetry.

Universal Deployment

Engineered for Everything from Laptops to Datacenter Racks

No high-end rig required. While it hits ~25µs on flagship hardware, Axobrier runs locally on virtually any modern machine.

Consumer & Mobile

Consumer & Laptop GPUs

  • Support: NVIDIA Pascal architecture and newer (Compute Capability 6.0+).
  • Examples: GTX 1060+, GTX 1660, RTX 2060, 3060, 4060, and mobile laptop variants.
  • Performance: 40µs – 90µs latency
Zero GPU Required

Pure CPU Mode

  • Support: Any x86_64 processor with AVX2 instruction sets (Intel 4th Gen Haswell+ / AMD Zen 1+).
  • Ideal for: Lightweight laptops, headless Linux servers, Docker containers, and GitHub Actions CI/CD runners.
  • Performance: ~400µs – 580µs (still >500x faster than cloud network round-trips).
Enterprise & Cloud

Enterprise & Workstations

  • Support: RTX 4090/5090, workstation Ada Lovelace, NVIDIA T4, L4, A10, A100, H100.
  • Footprint: <32 MB VRAM total footprint. Completely safe to run alongside heavy background processes.
  • Performance: 25µs – 42µs latency
The Hybrid Architecture

Don't Replace Frontier LLMs. Give Them an Instant Reflex Arc.

Pair the deep reasoning of cloud models with the microsecond speed of local deterministic cartridges.

01 Teacher Phase

Distill (The Teacher)

Use your favorite frontier model (Claude, GPT-4o, DeepSeek) to generate clean training examples for your specific routing domain (tool selection, triage, sentiment, intent).

Produces domain JSONL pairs with clean categorical target labels.
02 Compilation Phase

Compile (.axb Cartridge)

Run our single-command synthesis pipeline (python -m axobrier.cli train) to compile the decision matrix into an FP16 Brier-calibrated .axb file in under 3 minutes.

Fits exact Platt temperature scaling and Brier loss bounds.
03 Reflex Arc Phase

Run Locally (The Reflex)

Axobrier evaluates queries on your GPU or CPU in microseconds. If calibrated confidence is high (>0.95), execute instantly at $0 cost. If ambiguous, escalate to the cloud.

Filters 80%+ of repetitive decisions before touching cloud APIs.
Direct Breakdown

The Honest Comparison

How Axobrier measures up against paid cloud decision endpoints and generative LLMs.

Feature Axobrier (Local C/CUDA) Recommended Paid Cloud Decision APIs (like Jev) Heavy Frontier LLMs (Claude / GPT-4o)
Cost & Fees $0.00 Forever Zero Tokens Paid per API call / monthly subscription Expensive per-token generation pricing
Decision Latency 25 µs – 42 µs (Local Metal) > 1,500× Faster 70 ms – 500 ms (Network queue dependent) 1,500 ms – 4,000 ms (Autoregressive stream)
Data Privacy 100% On-Device / Air-Gapped Prompts & error logs leave your network Sensitive source diffs sent to third-party
Memory Allocation 0 Bytes Dynamic Allocation in VRAM Remote cloud server managed Remote cluster managed heap
Probability Calibration Grounded Platt & Brier calibration (.axb) Proprietary cloud score (RLCD) Overconfident / mathematically uncalibrated
Open Source License Apache 2.0 (100% Free & Permissive) Proprietary closed-source SaaS Proprietary closed API
Ecosystem Compatibility

Drop-In Reflex Arc for Your Existing Stack

Axobrier sits at the front door of your local and cloud agent loops, deciding routing in microseconds before waking up heavy LLMs.

Local LLMs

Ollama & Local LLMs

Stop burning 8GB of VRAM and waiting 1.5 seconds just to route a prompt. Axobrier classifies user intent or tool choices in 40µs, waking Ollama only when generative synthesis is required.

View Ollama Hybrid Recipe
Agentic Loops

Antigravity & Agentic Frameworks

Resident VRAM memory mapping for autonomous developer loops. Resolves tool selection (Grep, Read, Diff, Run) with sub-100µs deterministic reflexes.

View Antigravity Reflex Hook
IDE Rules & Extensions

Cursor, Windsurf & Codex

Drop into .cursorrules or IDE background agents to instantly triage compiler and lint failures without burning frontier token budgets.

View IDE Rule Snippets
Pipelines

CI/CD & Headless Runners

Pure AVX2 CPU execution on standard GitHub Actions or Docker workers. Triages broken builds in <500µs at $0 extra compute cost.

View GitHub Actions Workflow
// Technical Deep Dive & Specifications

Hardware Reflex Telemetry & ABI

Under the hood: fused C/CUDA FP16 reduction kernels, deterministic memory mapping, and zero dynamic heap allocation on the hot-path.

axobrier route — live output (sm_120 / sm_89) 42.18 µs total
$ axobrier route --cartridge models/build_triage.axb --query "Cannot find module 'express' or its corresponding type declarations. (TS2307)"
{ "status": "success", "choice_index": 3, "label": "MISSING_DEPENDENCY", "confidence": 0.9998, "raw_logit": 7.4619, "entropy": 0.0018, "latency_us": 42.18 }

Microsecond Execution Benchmarks

Stage p50 Latency Throughput
Fused Choice Kernel 25.03 µs 39,952 ops/s
Cartridge Route (Pooled) 38.40 µs 24,271 ops/s
CPU Fallback (AVX2) 184.20 µs 5,428 ops/s
Zero-Copy Hot-Swap 707.80 µs 1,413 swaps/s
Cloud API (e.g. Jev) 85,000 µs < 15 ops/s

C ABI Zero-Copy Memory Map 

#include "axobrier_core.h"

int main(void) {
    // 1. One-time GPU arena provisioning
    AxoContext* ctx = NULL;
    AxoConfig cfg = axo_config_default();
    axo_create(&ctx, &cfg);

    // 2. Zero-copy mmap cartridge into VRAM
    AxoCartridge cart;
    axo_cartridge_load_mmap("models/build_triage.axb", &cart);

    // 3. Sub-millisecond execution
    AxoDecision res;
    axo_evaluate_cartridge(ctx, &cart, &params, &res);

    printf("Choice: %s (%.2f us)\n", 
           axo_cartridge_get_label(&cart, res.choice_index), 
           res.latency_us);

    axo_destroy(ctx);
    return 0;
}

Cartridge Binary Specification (.axb v1)

+-----------------------------------------------------------------------------------------------+ | Axobrier Cartridge Binary Layout (.axb v1) | +--------+--------+------------+----------------------------------------------------------------+ | Offset | Size | Type | Description | +--------+--------+------------+----------------------------------------------------------------+ | 0x00 | 4 B | uint32_t | Magic Number: 0x00425841 ("AXB\0" in little-endian) | | 0x04 | 4 B | uint32_t | Specification Version (uint32_t = 1) | | 0x08 | 4 B | uint32_t | Hidden Embedding Dimension D (fixed at 256) | | 0x0C | 4 B | uint32_t | Cardinality C (Number of candidate choices) | | 0x10 | 4 B | float32 | Platt Scaling Temperature Parameter (IEEE 754) | | 0x14 | 4 B | float32 | Platt Scaling Bias Parameter (IEEE 754) | | 0x18 | 4 B | uint32_t | Length of null-delimited UTF-8 label section in bytes | +--------+--------+------------+----------------------------------------------------------------+ | 0x1C | C*D*2B | fp16[...] | Choice Matrix: FP16 weights [C × D] mapped directly to GPU | +--------+--------+------------+----------------------------------------------------------------+ | VAR | N B | char[...] | UTF-8 Null-Delimited Labels (\0-separated string table) | +--------+--------+------------+----------------------------------------------------------------+

Release Verification Checksums (SHA-256)

axobrier-v0.2.0-windows-x64.zip (152 KB) 37a2c96aba4282987c1b9a1f26ca60ae0028ce19bf3009a70f257b1594aeda6d
models/build_triage.axb (Compiler diagnostic router, C=7) c1e1bad43117fb047e2b9e02eac954a87d31bc15ef6f278e53b03e6781bbae09
models/agent_router.axb (Autonomous agent tool selector, C=7) 4c975b5d7cec9d5fcfcfef6c78981368134c8eda38533ed9a561523fc8c587d3