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.

See Use CasesBack to Home
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 logsNot samplingNot static analysisReal execution traces5 years · production workloads
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 is different
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
  • No runtime overhead — analysis happens offline
  • No new build steps — reads existing CI artifacts
  • Works on object files (.so) during development, full binaries at build
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

See the signals in action.

Five execution signals from a model trained on five years of real production workloads — firing from binary, before a single line ships.

Explore Use CasesView Docs