LMTI · Public Alpha
Compile codebase structure, project rules and verified operating lessons into a local Context Pack before an agent changes source code.
Local-first
Public Alpha
Open source
The practical problem
A coding agent can analyze well inside one session. The gap appears when that understanding does not become reusable operational state for the next task.
Receive a new task
Search the entire repository
Read many unrelated files
Guess architecture and rules
Repeat old mistakes or mix project context
Identify project and intent
Atlas provides the codebase map
Memory adds verified lessons
Privacy gates filter sensitive data
Thoth routes the relevant skill
Agent receives minimum sufficient context
How LMTI works
LMTI does not write code on behalf of developers. It prepares context, boundaries and evidence so the agent starts from a better position before inspecting source and proposing changes.
Identify the project, task type and intended scope.
Retrieve relevant modules, files, dependencies and rules.
Combine context, verified lessons and security boundaries.
Keep memory as prior belief and require source or tests to confirm it.
Core layers
LMTI does not write code for developers. It prepares context, keeps data boundaries explicit and helps the agent start from the relevant surface area.
Compiles a repository into AMF: project metadata, modules, files, symbols, dependency edges, API/database hints, rules, risks and architecture notes.
Stores decisions, lessons, incidents and operational knowledge with short-term and long-term lifecycle.
Selects minimum sufficient context, filters sensitive data and suggests the right skill based on task intent and risk.
Core value
Agents start from a compiled project map instead of rediscovering the codebase from scratch.
Only the context relevant to the current goal is selected, avoiding long prompts that miss the point.
Evidence-backed lessons can be reused in later tasks without becoming absolute truth.
Project state, memory and audit data are designed to live in `.lmti/` inside the local workspace.
Technology and architecture
The stack is presented as a technical specification, not a buzzword list. Experimental pieces are separated from what works now.
CLI experience
The public repository currently verifies the Node CLI path after building from source. This page does not show global install commands while package distribution is not the primary verified path.
$ corepack pnpm install
$ corepack pnpm build
$ corepack pnpm test
$ node packages/cli/dist/index.js context "fix a routing bug"
$ node packages/cli/dist/index.js preflight "prepare release" --adapter codex
$ node packages/cli/dist/index.js doctor --securityLMTI is currently in Public Alpha. Run from source according to the repository documentation.
Read the repository documentation$ node packages/cli/dist/index.js context "fix a routing bug"
Intent: routing bug
Atlas: routes, middleware, auth
Memory: verified lessons only
Privacy gate: no secrets in context
Next: focused verification planProduct illustration only. This is not real runtime data or a customer project log.
Use cases
Help an agent orient inside an older project and identify relevant modules before changing code.
Create a shared project context layer for Codex, Claude Code, Cursor or other agents without claiming every adapter is production-ready.
Keep business rules, permissions, deployment notes and lessons structured for long-running systems.
Benchmark and evidence
LMTI is not evaluated by how many features it claims to have. It is evaluated by whether agents explore less, retrieve better context, repeat fewer mistakes and respect project boundaries.
Public Alpha, not a complete production-grade product.
Open source / creator
LMTI began from a practical problem while working with AI coding agents on long-running software projects: an agent can analyze well in one session, but that understanding often does not become reusable operational state for the next task.
FAQ
LMTI is a local-first project intelligence and operating context layer for AI coding agents.
It helps agents start with relevant context, verified lessons and privacy boundaries instead of rediscovering a project from scratch.
Atlas compiles a repository into AMF, a structured project map of modules, files, dependencies, rules and risks.
Thoth routes skills based on task intent and risk. It does not code by itself or bypass policy.
No. LMTI is not an LLM or a new AI model. It is a context, memory, privacy and skill-routing layer.
No. LMTI supports agents with better context, but it does not replace developers, testing or review.
Local state is designed to live in `.lmti/` and `.atlas/` inside the workspace, without requiring a cloud backend.
No. LMTI is in Public Alpha. APIs and storage schemas may change.
Public Alpha · Local-first · Open source
Start from real source, documentation and boundaries. LMTI turns that understanding into local-first operating context for AI coding workflows.