L

LOCI

by Aurora Labs
Contact Us

Technology Deep Dive

A model trained on five years of real production workloads.

LOCI’s execution signals don’t come from rules or heuristics, they come from a model trained on real-time traces collected over five years from production CPU and GPU workloads. It reads binary files. It predicts before code runs.

HOW LOCI'S MODEL IS BUILT - AND WHAT IT RUNS ON

5 Years of Data

Real-time traces from production workloads

CPU & GPU traces

Binary Input

ELF · Mach-O · PTX · Wasm

Any compiled target

Execution Model

Trained on real hardware behavior

Not heuristics. Not rules.

5 Signals

Response · Throughput · CFI · Flame · Power

Fires before code ships

Agent-Ready

Ground any AI coding agent

First-pass accuracy. Zero rework.

Not logs

Not sampling

Not static analysis

Real execution traces

5 years · production workloads

Book a Demo
See Use Cases
Data Foundation

Five Years of Real Execution Traces

LOCI’s model is built on something no heuristic can replicate, five years of real-time traces collected from production CPU and GPU workloads running real software.
  • Real-time hardware performance counters
  • CPU and GPU execution traces from production systems
  • Timing, power, and throughput measurements at instruction level
  • Collected across diverse workload types and hardware generations

Why this matters

Most tools are built on synthetic benchmarks or hand-crafted rules. LOCI’s training data is real software, running on real hardware, over five years.
Binary-First

Binary Files as Input - Not Source Code

LOCI reads compiled binaries directly – ELF, Mach-O, PTX/SASS, and Wasm. The source language is an input, not a constraint.
  • ELF, C, C++, Rust, Go, Zig
  • Mach-O, Swift, C/C++ on Apple platforms
  • PTX / SASS — CUDA kernels and GPU compute
  • Wasm - WebAssembly targets
  • JVM bytecode, CPython bytecode

Key insight

The binary encodes how code will execute, control flow, instruction sequences, memory layout, without needing to run it.
The Model

An Execution Model Trained on Reality

Not a rule engine. Not static analysis. LOCI trains a model on real execution behavior, so predictions reflect how hardware actually runs code, not how engineers think it should.
  • Trained on measured instruction throughput and latency
  • Learns branching, divergence, and memory hierarchy effects
  • Models CPU/GPU scheduling behavior from real workloads
  • Trained on boundary measurements, upper and lower execution bounds per function
  • Outputs are numeric, physically meaningful values (ms, watts, instructions/cycle)
  • No hallucination, signals are bounded by binary structure, not generated from text

No hallucination, by design

LLMs generate tokens. LOCI predicts within measured execution bounds. Every signal has a floor and a ceiling derived from real hardware traces, a value outside those bounds is structurally impossible.
5 Signals

Five Execution Signals, Before the Code Runs

Every signal is a prediction from the model, fired from the binary, available before a single test runs or a line ships.
  • Response Time - latency bounds per function
  • Throughput - instructions and operations per cycle
  • Call Graph / CFI - control-flow integrity and call paths
  • Flame Graph - hotspot prediction across the call stack
  • Power / Energy - per-function energy cost estimate

When it fires

As you code (incremental .so), after full build, during test, and at PR merge, each stage independently useful.
AI Grounding

Ground Any AI Coding Agent

AI coding agents reason from source code alone, they have no sense of how code actually executes. LOCI gives them that missing layer.
  • Plan features against real execution bounds before writing
  • Resolve bugs from signal evidence, not trial-and-error
  • Gate every PR with a precise signal diff, not binary pass/fail
  • Works with Claude Code, Cursor, Copilot, Gemini, and any MCP-compatible agent

The outcome

Higher first-pass accuracy. Lower token burn. Your team codes until 6pm, not until the daily cap shuts them down.
Zero Overhead

No Instrumentation. No Runtime Required.

LOCI runs entirely from the binary artifact. No agents to deploy, no profilers to configure, no runtime hooks.
  • No code changes or annotations required
  • Comparable across buNo runtime overhead, analysis happens offlineilds
  • No new build steps, reads existing CI artifacts
  • Works on object files (.so) during development, full binaries at build

Guarantee

Because predictions are bounded by executable structure and real hardware behavior, hallucinated outputs are structurally impossible.
Incremental

Signals From the First Line Written

LOCI doesn’t wait for a full build. It compiles incrementally, isolated object files per function or module, so signals are available as code is written.
  • Analyzes small .so files compiled per function or module
  • Similar to Compiler Explorer, continuous, lightweight feedback
  • fn-level signal while you type, full program signal after build
  • No binary yet? No problem, LOCI fires from the first compiled object

Analogy

Think of Compiler Explorer, but instead of showing assembly, LOCI shows execution signals: response time, throughput, power.
Production-Grade

Built Also for Performance-Critical Systems

LOCI works across any compiled target, and is especially suited for teams where performance, power, and correctness are non-negotiable: AI inference, networking, HPC, embedded, and data center workloads.
  • AI training and inference systems (LLM, diffusion, vision)
  • Networking and infrastructure software
  • High-performance computing and scientific workloads
  • Embedded and edge systems with power constraints

Principle

Correctness, predictability, and trust over speculative reasoning. Real data. Real hardware. Real signals.
Next Step

Want a walkthrough on LOCI’s execution signals?

See how executable decomposition + hardware-grounded models translate into bounded, actionable signals inside CI, IDEs, and LLM coding agents.
View Docs
Explore Use Cases
Skip to content