From Plan to Merge,LOCI Thinks Ahead.
Every AI-generated change receives engineering judgment before merge.LOCI predicts what the code will do, warns about regressions, and guides the coding agent toward a better implementation.Works alongside Claude Code, Cursor, Copilot, and your existing development workflow.
From execution evidence to an engineering decision.
- 01
Define acceptable behavior
Declare requirements, permitted behavior, operating modes and input assumptions in the Contract Envelope — and why the behavior matters: output quality, useful progress, a permitted path, capacity.
- 02
Connect the execution artifact
Provide the compiled candidate, target and repository context. During /plan, LOCI works from a relevant existing artifact; changed native code is built before analysis of that candidate.
- 03
Obtain execution evidence
LOCI's learned execution models and analyzers supply target-specific predictions and structural evidence. Evidence about one subsystem is an input to the reasoning, not the whole application conclusion.
- 04
Reason about consequences
The plugin and skills guide your coding agent in relating evidence to paths, dependencies and operating conditions — connecting a timing or resource effect to what it costs the application.
- 05
Revise the decision, then validate
Change the plan or the code, support a configured CI decision, or keep an unresolved condition explicit. Testing, simulation, profiling and HIL assess the actual behavior and the revision.
Measured behavior underneath, engineering reasoning on top. Predictions supply evidence, analyzers and context enrich it, the coding agent reasons about the application. These layers work together without being interchangeable.
See the consequence. Change the plan.
A deadline breach is not a “slow function”
Deadline breach caught
llProcessCentral · 48,284 / 45,000 ns · 107% of budget
Worst regression caught
powerNotifyCb · 266 → 704 ns · +164.7%
The envelope declared 45,000 ns. The measurement came back over it. That is not a ranking of slow functions — it is a stated limit and a value that crossed it, before merge.
The engineer question: is 45,000 ns still the right budget for this mode — or is the work in the wrong place?
A wait becomes a quality problem
CPU dispatches work → waits for accelerator → buffers remain held
Sustained arrivals, a limited buffer pool, and buffers retained until accelerator work completes. Longer waits raise buffer pressure and the age of the data being processed — so the application keeps producing outputs while those outputs become less useful.
The useful decision is not “make one function faster.” Revisit synchronization and dispatch, bound in-flight work, choose a backpressure or dropping policy the application permits.
The engineer question: must every item be processed, or is bounded backpressure allowed in this mode?
Waiting alone does not establish memory pressure or degraded quality. The dependency, workload and freshness assumptions are necessary. This is conditional reasoning, not full-system simulation and not an automatic fix.
AI writes. LOCI predicts the consequences.
Claude Code writes the change. LOCI acts as the execution-aware Guardian — predicting what the change will do, warning about regressions, and guiding the agent toward a better implementation before merge.
How LOCI thinks ahead
Increase paged attention throughput.
Double-buffered K tiles.
⚠ Register pressure exceeds budget.
This will spill and reduce performance.
Recommendation: Use single-buffered K tiles.
Good catch.
Updating implementation.
✓ Within budget
✓ 1.32× faster
↓ the full session & live cockpit
Live verdict
watching the session…Engineering impact
Hover a metric to trace it in the story ↑
LOCI activity
Contract envelope · cost vs budget
Top CPU
Top energy
LOCI caught it. Claude fixed it. Here’s what that’s worth.
One AI-generated change, measured — not a marketing number.
First-pass success
Recommendations accepted
Review time saved
Regression prevented
Two moments. Both before the run.
The same evidence at /plan, while the design is still cheap to change — and at the merge gate, before the change reaches the queue.
Two moments. Both before the run.
The same evidence at /plan, while the design is still cheap to change — and at the merge gate, before the change reaches the queue.
- Verdict + evidence in seconds
- Trained on real workloads + platform traces
- No instrumentation, no runtime
- Claude Code · Cursor · Copilot · agent-agnostic
Also supportsCopilot·Cursor·GitHub App·GitHub Actions·Azure DevOps
One guardian. Engineering judgment at every stage.
Wherever your coding agent works, LOCI predicts execution, warns about regressions, and validates every stage.
Plan
loci preflight · MCP
Predict execution.
See the round-tripWrite
loci post-edit · MCP
Catch implementation mistakes.
See how /post-edit talks backPR
quality finding
Review quality.
See the PR reviewMerge
contract envelope
Validate contract envelopes.
See the contract envelopeEach stage is independently useful, or run the full layer for continuous coverage.
Keep every merge inside its contract envelope.
Performance, power, memory, latency — define the limits once. LOCI measures every AI-generated change against them before merge.
4
Guarded
1
Proposed
0
Violations
0
Twin commits
T_IFS critical path envelope
135.00 µs
72.00 µs measured
RF + LL ISR combined
(RF_scheduleCmd path + Hwi_dispatchC + Swi_run)
RF command path (FSM + schedule + dispatch)
3.50 µs
2.42 µs measured
RF_fsmActiveState + RF_scheduleCmd + Hwi_dispatchC
ISR total latency
1.85 µs
1.19 µs measured
Hwi_dispatchC (≤ 1.2 µs) + Swi_run (≤ 650 ns) combined
OSAL heap alloc worst-case
0.25 µs
0.25 µs measured
osal_mem_alloc on CC2674P10 · LOCI-derived from osal_memory.c
Top heap sites (skeleton)
totalStaticB: 6,144 B
osal_mem_alloc → osal_pool_alloc (32 B)
Stack envelope
+
Add your envelope from loci.contract.toml
Energy envelope
+
Define mJ-per-event budgets the gate will enforce on merge
Real measurements · TI BLE5-Stack · CC2674P10
Set the engineering rules once. LOCI guards within them.
Choose how autonomous LOCI should be — observe, advise, block, or auto-correct. Per gate, per repo.
Silent surface. Evidence available on demand. Zero PR noise.
PR comment with verdict + drill-down. Never blocks; you decide.
Blocks merge on critical-gate failure. Advises on the rest.
Takes corrective action (reject PR · open revert · escalate). Notifies you after.
You set the rung for Safety, Performance, Power, and AppSec independently. Every verdict is logged and reversible.
Static analysis stops at the source. A profiler stops at the run you took. Neither tells you what will happen.
A profiler
- Needs a scenario someone writes, maintains and keeps representative
- Reports the run you took, not the one you fear
- The probe changes the timing it measures
- No worst case. No paths you did not exercise.
Testing · simulators
- Scenarios must be written, then continuously developed as the system changes — roughly 15–20% of a sprint
- Only covers what a scenario thought to exercise
- Every run costs a slot, a rig, or hours
Static analysis · coding agents
- Read the source, never the binary
- Structure, not behavior
- No timing, power or memory at all
agent claims: “tighter constant-time compare on auth path”
LOCI · bound to systems physics
ecdsa_sign() · constant-time property lost
WCET sweep across input patterns · floor-to-ceiling spread · ⛔ OUT OF ENVELOPE
timing correlates with secret-bit count · CVE-2019-1547 pattern
blocked at the merge gate — the same engine that catches a missed deadline.
Static analysis has no rule for “manual loop with early exit.” LOCI models the variance.
Prove value on one behavioral risk and one decision.
Compare the concern, the plan change and the later validation — not just the prediction.
One behavior
Select a repository, target and change with a meaningful application consequence.
The contract
Specify acceptable behavior, permitted modes, workload assumptions and missing context.
The decision
Compare the original approach with LOCI-assisted reasoning and the resulting plan or code change.
The outcome
Check the concern and the revision. Record false alarms, gaps and findings that did not help.
Install Plugin in minutes. Same Guardian. Same engineering judgment.
Use LOCI inside Claude Code and get execution-aware intelligence inside every agent session. No workflow changes. No runtime. No instrumentation.
Know how your software behaves before it runs.
Give your coding agent engineering judgment.