Everything it does

What Latorium helps with

01

Less context, same question

$ claude "why does checkout double-charge?"

→ latorium.context_packet
  scanned 412 files · returned 3 excerpts
  14,000 chars delivered

  the rest was never opened

Send relevant files first, so the agent does not search the same repository again.

02

Why this code?

$ latorium.local_search "checkout discount"

→ 3 results, each with its reason
  checkout.ts        direct match
  discounts.ts       used by checkout
  checkout.test.ts   tests this behavior

  a weak match is visible before the agent trusts it

Each result says why it was picked. You can spot a weak match before the agent relies on it.

03

Know what could break

$ latorium.impact_of_change payment.ts

→ 3 callers · 2 tests affected
  checkout.ts · invoice.ts
  payment.test.ts · billing.test.ts

  high risk — shown before you approve

See callers, dependencies, and affected tests before you approve the edit.

04

Undo only the broken part

$ npm test

→ 1 of 3 changes failed its check
  parser.ts      kept
  report.ts      restored
  dashboard.ts   restored · depends on report.ts

  the passing work stays

If one part fails, Latorium restores that part and anything that depends on it.

05

Agents stop colliding

$ latorium.list_tasks

→ 3 claimed · no overlapping files
  codex         api validation
  claude        settings UI
  local coder   test scaffold

  ownership is visible before an edit

A shared task board shows who owns each file before two agents edit it at once.

06

The right power for the task

$ latorium.local_coder_draft

→ routed on measured results
  small CSS fix      4B · fastest proven fit
  multi-file change  8B · stronger record

  measured on your machine

Use Local Coder for work that suits a local model.

Find the right code first

Latorium searches the project before your coding agent starts opening files. The same search is used for chat, edits, reviews, and task planning.

Its job is to reduce repository reading before the agent begins work.

On the current evaluation set, semantic ranking returned a relevant result in its first five positions for 94% of queries, and in its first ten for every one of them. The dashboard measures the same behaviour on your own project.

What you can ask it to do

Find where something lives, plan a feature, check what an edit might break, or split work between agents. The full tool list is available under Advanced.

Read the plain-English function guide

Show the complete technical tool list

local_search: Finds where something lives. Returns ranked excerpts with paths and line numbers, so one call replaces a grep and several file reads.
context_packet: Everything needed to start a task, in one call: the project file map plus the excerpts that matter, bounded to a size you set.
context_review: Names what has gone stale in the window, so it stops being re-read on every subsequent turn.
deep_search: Widens a weak search in bounded rounds and returns the best result, not merely the last one.
project_brief: Reports the project type, declared checks, branch, rebase state, and work already in progress before an agent edits.
plan_change: Orders multi-file work dependency-first and calls out cycles that must change together.
impact_of_change: Shows importers, dependencies, affected tests, and an explained risk score before a file changes.
plan_context_eviction: Drops stale context, replaces edited copies with current code, and preserves anything explicitly pinned.
local_coder_draft: Hands routine work to Latorium Local Coder. Summaries, test scaffolding, boilerplate. Output is a draft nobody applies without you.
create_task: Splits independent work into tasks on a shared board.
claim_task: Claims one, so two agents never edit the same files.
list_tasks: Reads what other agents have finished.
report_result: Records changed files, tests run and decisions taken, for the next agent to pick up.
report_verified_learning: Stores a lesson only after deterministic checks pass and you accept the result. Redacted, and restricted to a fixed model allowlist.
report_draft_outcome: Measures what survived from a local draft, so discarded output is never presented as a saving.
efficiency_report and drafting_yield: Separate measured input reduction from kept-output savings and show which kinds of local drafting are worthwhile.

How code search improves over time

Search starts with names and keywords, then uses project structure and meaning when available.

Semantic retrieval: Finds related code even when your question uses different words. This is optional.
Build Semantic Index: Embeds the workspace once, visibly and cancellably. Never runs inside a retrieval call.
Keyword ranking: The fallback, and exact when you already know the symbol name. Always available, needs no model.
Saved dashboard: Counts what was kept out of context, per agent, read from the session logs Claude Code and Codex already write. Counters only, never prompt or response content.
Efficiency benchmark: Tests the selected model on this machine and records the result.
Copy Compact AI Context: Puts a bounded context packet on the clipboard for pasting into any tool, including ones that do not speak MCP.
Health report: Shows which setup item needs attention.

What Local Coder handles

Latorium Local Coder handles everyday work on your computer, and everything it does stays there.

Chat panel: Ask Local Coder directly, with the same retrieval in front of it.
Explain selected code: Reads a selection and describes it. Changes nothing.
Edit selected code: Proposes a change to a selection, for review.
Multi-agent planning: Splits a larger request into tasks across the shared board.
Permission modes: Review every edit, auto-approve edits but not deletions, or full workspace access. You choose, and it defaults to the cautious one.
Recover interrupted changes: Restores a checkpoint when something stops halfway.
Safety evaluation: Runs a deterministic suite checking that unsafe operations are refused.
Failure lessons: Keeps what went wrong last time so the same mistake is not repeated. Clearable at any point.

Generated changes remain drafts until the selected permission mode allows them. Model results are available in the benchmark dashboard.

A complete local workbench

The extension now handles setup, daily work, measurement, and recovery from one sidebar.

One-button setup and repair: First run installs or connects the Latorium Local Coder runtime, downloads the recommended model, checks it can answer, and offers clear retry or installer recovery.
Hardware-aware model updates: Signed release manifests select the strongest compatible model from available RAM, ask before downloading, smoke-test it, and switch only after it works.
Preview and tests: Open a project or HTML preview with reload-on-save, then run the repository's declared tests and follow their output without leaving Latorium.
Benchmark Lab: Test retrieval on the current workspace or five pinned public projects, inspect every expected and retrieved file, repair setup, and run all repositories sequentially.
Measured overview: See retrieval reduction, agent-attributed context packets, request latency, test outcomes, first-pass success, and drafting yield from local audit counters.
Portable evidence: Export checksummed, redacted benchmark bundles and use comparable results from similar hardware without letting thin evidence change routing.

Accounts without sending your code

Email or GitHub sign-in unlocks paid capabilities, while repository content, prompts, embeddings, diffs, memory, and Local Coder output stay out of the licensing service.

Offline-verifiable access: Short-lived signed entitlements are cached and verified locally, with an offline grace period and a Free fallback instead of a broken extension.
Revocation and refund safety: Withdrawn licences, full refunds, disputes, cancellations, and renewed subscriptions propagate without trusting forged or unavailable responses.
Hardened release package: The customer VSIX contains two minified bundles, no source maps or internal training material, and is scanned for secrets and forbidden paths before release.

What still stays with your coding agent

Latorium works alongside your coding agent.

Guided setup installs Latorium Local Coder.
Claude Code, Codex, and other agents still make their own decisions.
Cloud agents receive the selected context under their provider's terms.
Latorium Local Coder runs AI requests on the computer. Paid plans refresh account status online.
Deletion always requires approval.

Current development build

The v0.50.0 foundation now includes the later setup, account, benchmarking, model-release, and package-hardening work described above.

20-scenario adversarial suite: All catalog scenarios run end-to-end in cross-platform CI.
Benchmark matrix runner: Runs bounded repository × model × repeated-run matrices, with sequential model execution to avoid VRAM thrashing.
History retention: Bounds benchmark artifacts by age, count and storage, with dry-run pruning before anything is removed.
Combined release gate: Verification joins tests, adversarial checks, compilation, bundling, secret scanning and regression checks into one release decision.
Package secret scanning: Scans the packaged VSIX; during development it caught a credential-shaped fixture before release.

Current verification: 746/747 of Latorium's own tests passed (one skipped, it needs symlink privileges) and 20/20 adversarial checks passed. Checked 19 September 2026.

Give your coding agent less repository to read