Amplifier Platform

From Reading Code
to Understanding It

Full language intelligence for AI agents.
14 LSP operations. First-class Rust support. Zero external dependencies.

✓ Active
Primary contributor: samschillace · February 2026
The Problem

AI agents can search text.
They can't understand code.

🔍
grep finds strings
Text matching can't distinguish function calls from comments. "What implements this trait?" returns noise, not answers.
🧩
No semantic graph
Without type information, agents can't trace call hierarchies, understand generics, or verify their own edits compile.
🔄
Broken feedback loop
Write code → shell out to compiler → parse raw text output → hope you fixed it. Slow, fragile, error-prone.
The Insight

Language servers solved
this for humans.

Every IDE uses LSP for go-to-definition, find-references, rename, and diagnostics. Now we bring the same intelligence to AI agents.

The Toolkit

14 operations across 6 categories

7 base (always available) + 7 extended (capability-gated per server).

goToDefinition
findReferences
hover
documentSymbol
prepareCallHierarchy
incomingCalls
outgoingCalls
goToImplementation ✦
workspaceSymbol ✦
diagnostics ✦
rename ✦
codeAction ✦
inlayHints ✦
customRequest ✦
✦ Extended (capability-gated) Navigation · Call Hierarchy · Verification · Refactoring · Inspection · Extensions
The Centerpiece

Diagnostics closes the
read-write feedback loop

Before: Shell Out
# Agent writes code, then... $ cargo check 2>&1 error[E0277]: the trait bound `MyStruct: Serialize` is not satisfied --> src/main.rs:42:5 | 42 | serde_json::to_string(&val) | ^^^^^^^^^^^ the trait | `Serialize` is not | implemented # Parse raw text. Hope for the best.
After: LSP Diagnostics
# Agent writes code, then... LSP.diagnostics("src/main.rs") → [{ line: 42, severity: "error", code: "E0277", message: "trait Serialize not implemented", codeActions: ["Add #[derive(Serialize)]"] }]
Why this matters
The agent verifies its own edits compile through LSP — structured data, precise line numbers, and suggested fixes. No more shelling out to cargo check and parsing text.
Extended Operations

What the 7 extended operations enable

Verification
diagnostics
Get compiler errors and warnings for any file. The agent's compile-check without leaving the LSP.
Refactoring
rename · codeAction
Semantic rename across files — 13 precise edits in 5 files from one call. Code actions suggest and apply fixes.
Navigation
goToImplementation
Find every trait implementor across the entire workspace. Including blanket impls, generics, and dependency crates.
Inspection
inlayHints
See what the compiler infers — types, parameter names, lifetimes — even when the code has zero annotations.
Extensibility
customRequest
Send any server-specific method. Rust: expandMacro, relatedTests, externalDocs. Fully extensible per language.
Dynamic
Smart filtering
LLM only sees operations the configured server supports. No confusing the model with unavailable capabilities.
First-Class Language Support

Rust gets the
full treatment

The lsp-rust bundle (now rust-dev) integrates rust-analyzer with a persistent proxy server and a specialist agent for multi-step code investigations.

Real Results

What rust-analyzer delivers

28
Cross-crate references
in one call
13
Precise edits across
5 files (one rename)
40
Inferred types + params
from one function
24
Outgoing calls traced
including stdlib
Autonomous investigation
The rust-code-intel agent traced a trait hierarchy across 3 crates in a single autonomous session — no human intervention.
Full proc-macro expansion
Expand #[derive(Debug)], serde macros, and custom derives via customRequest — see exactly what the compiler generates.
The Killer Feature

goToImplementation

The single strongest argument for LSP over grep in Rust.

grep for implementors
# Find all implementors of Handler trait? $ grep -r "impl Handler" src/ src/api.rs: impl Handler for ApiHandler src/ws.rs: impl Handler for WsHandler src/test.rs: // impl Handler mock ← false positive src/doc.rs: /// impl Handler pattern ← noise # Misses: blanket impls, generic impls, # impls in dependencies, re-exports...
LSP goToImplementation
# Every implementor. Every crate. Precise. LSP.goToImplementation( "src/traits.rs", Handler ) → [ ApiHandler src/api.rs:15 WsHandler src/ws.rs:8 BatchHandler src/batch.rs:22 ProxyHandler deps/proxy/src/lib.rs:44 ] # Including blanket impls, generics, deps ✓
All trait implementors found across the entire workspace — including blanket implementations, generic bounds, and implementations in dependency crates. grep literally cannot do this.
Infrastructure

The cold-start problem,
solved

rust-analyzer needs 30–90 seconds to index a large workspace. That's fine once — but not every session.

Session 1
Cold start: 60s index
→
Persistent Proxy
Keeps server warm
→
Session 2+
Instant connect
Auto-restart on crash
If rust-analyzer crashes, the proxy automatically restarts and re-indexes. Agents never see downtime.
Idle timeout
Server shuts down after configurable idle period. No wasted resources when you're not coding.
Cross-session discovery
State files let new sessions discover running proxies. Queue-based stdout reading ensures reliable communication.
Architecture

Three-layer composition

Each layer adds capability without duplicating code. The thin bundle pattern means zero module code — pure YAML composition.

tool-lsp module
14 ops + proxy
→
lsp-rust bundle
Deep merge + config
→
Specialist agent
Multi-step investigations
0
External dependencies
Python stdlib only
421
LSP test functions
amplifier-bundle-lsp
14
LSP operations
Dynamically filtered
∀
All languages benefit
Not just Rust
The thin bundle pattern: amplifier-bundle-lsp-rust has zero module code. It's pure YAML — composing tool-lsp's capabilities with rust-analyzer configuration and a specialist agent description.
Ecosystem Impact

Every language
gets smarter

All 14 operations ship in the base tool-lsp module. Rust, Python, and every future language bundle gets them automatically.

🦀
Rust
rust-analyzer via lsp-rust bundle. All 14 operations including macro expansion via customRequest.
🐍
Python
Pyright via python-dev bundle. lsp-python is deprecated — python-dev forwards all LSP operations.
🌐
Any Language
Add any LSP-compatible server. TypeScript, Go, C++ — the architecture supports them all.
Development Velocity

Built with purpose

3
Repositories
14
LSP Operations
421
LSP Test Functions
0
External Deps
amplifier-bundle-lsp amplifier-bundle-lsp-rust amplifier-bundle-python-dev
~442 total ecosystem tests (421 LSP + 21 python-dev)
Sources

Research Methodology

Data as of: February 20, 2026

Feature status: Active (tool-lsp is in production and in the active cache)

Research performed:

Corrections from prior version: Previous deck stated "17 operations" and "488+ tests." Verified counts are 14 operations and 421 LSP test functions. The prior count included type hierarchy operations (prepareTypeHierarchy, supertypes, subtypes) that are not in the current codebase.

Gaps: Rust results (28 refs, 13 edits, etc.) are from test sessions, not production telemetry. No usage frequency data is available for individual operations.

Primary contributor: samschillace (sole author of all three repositories)

What's Next

Stop searching.
Start understanding.

Language intelligence is now a core Amplifier capability.
14 operations. 421 tests. Zero external dependencies.

📦
amplifier-bundle-lsp
Core LSP module
🦀
rust-dev
Rust + rust-analyzer
🐍
python-dev
Python + Pyright
Amplifier Platform · Language Intelligence · February 2026
More Amplifier Stories