A model trained on five years ofreal-world execution.
LOCI's execution guardian doesn't rely on rules or heuristics. It's powered by LCLM — small, specialized code language models trained on billions of ASM blocks and real-time traces from open-source projects spanning IoT, networking, safety-critical, and industrial systems. ~220× cheaper per query than general LLM tokens. It reads binary files. It predicts before code runs.
Inputs
Real-time traces from open-source projects
CPU & GPU traces
ELF · Mach-O · PTX · Wasm
Any compiled target
Trained on real hardware behavior
Not heuristics. Not rules.
Outputs
Timing · Throughput · Stack · Power · Risk Paths
Fires before code ships
Ground any AI coding agent
Higher first-pass accuracy. Fewer debug cycles.
Inputs
Real-time traces from open-source projects
CPU & GPU traces
ELF · Mach-O · PTX · Wasm
Any compiled target
Trained on real hardware behavior
Not heuristics. Not rules.
Outputs
Timing · Throughput · Stack · Power · Risk Paths
Fires before code ships
Ground any AI coding agent
Higher first-pass accuracy. Fewer debug cycles.
Five Years of Open-Source Execution Traces
LCLM is a small, specialized model built on something no heuristic can replicate — five years of real-time traces collected from open-source projects running on real hardware. Billions of ASM blocks across IoT, networking, safety-critical, and industrial systems. ~220× cheaper per query than general LLM tokens.
- Real-time hardware performance counters
- CPU and GPU execution traces from open-source projects
- Timing, power, and throughput measurements at instruction level
- Collected across diverse workload types and hardware generations
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
LCLM — A Small, Fast Execution Model Trained on Reality
LCLM is a small, specialized model trained on real execution behavior — not a general LLM. ~220× cheaper per query. Predictions reflect how hardware actually runs code, not how engineers think it should. Not a rule engine. Not static analysis.
- 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
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.
- Timing & Latency — response time and p95/p99 bounds per function
- Throughput — instructions and operations per cycle
- Stack & Memory — worst-case stack depth and memory pressure
- Power & Energy — per-function energy cost estimate
- Risk Paths — CFI, worst-case execution paths, and attacker-reachable branches
Execution Guardian for Any AI Coding Agent
AI coding agents reason from source code alone — they have no sense of how code actually executes. LOCI is the guardian agent that fills that gap — shifting execution signals into the workflow before code ships.
- Preflight audits the agent's plan before code is written
- Post-edit catches quality regressions after code changes
- Guard every PR — approve or block with evidence
- Works with Claude Code, Cursor, and Copilot via MCP. Available for 15+ agents via skills.sh. Listed on AWS Marketplace.
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
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
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
A guardian agent that runs from the compiled binary with zero overhead. But if it's autonomous — who guards the guardian?
Who guards the guardian?
Physics, verifiability, and human oversight.
- Deterministic
Same binary in, same signals out. Every time. No probabilistic variation, no prompt sensitivity, no temperature knob. The output is a function of the binary — not a guess.
- Bounded by physics
Every prediction has a measured floor and ceiling from real hardware. LCLM cannot hallucinate a value outside observed execution bounds.
- Verifiable on hardware
Every prediction can be validated by running the binary on real hardware. No black box — inspect, compare, confirm.
- Trained on reality
Five years of real execution traces from open-source projects on real CPUs and GPUs. Not synthetic benchmarks, not hand-crafted rules.
- Human-on-the-loop
Decision layers are opt-in. Start with full human review, hand off to agentic when you're ready. Every level keeps a full audit trail.
- 120+ granted patents
The core technology is peer-reviewed through the patent process and defensible across US, EU, Japan, and additional markets.
You decide when to let go
From human-on-the-loop to fully agentic.
Not in-the-loop — that pauses the agent on every step and doesn't scale. On-the-loop means LOCI runs automatically and the human reviews the verdict, not the code. Each decision layer is opt-in. Hand off when you're ready.
LOCI surfaces verdict on every PR. Human approves or blocks each one.
Set regression budgets. LOCI auto-passes PRs within budget, flags only exceptions for human review.
LOCI auto-approves or auto-blocks based on your quality contract. Human can override any decision.
LOCI runs as an autonomous guardian inside the agentic workflow. Human is notified, not required. Full audit trail retained.
Every level keeps a full audit trail. Every decision is logged, traceable, and reversible. You choose the level — per repo, per team, per signal.
Start guarding your code. First verdict on your next commit.
Five signals. One execution guardian. Install in minutes — no instrumentation, no runtime overhead.
The model under the gate. By the numbers.
Reference card for the execution model that powers every LOCI signal.