Ane is a fresh take on chord-based terminal editing that treats AI agents as first-class citizens. Built by the folks at prettysmartdev, ane integrates Language Server Protocol support directly into its core, allowing code agents to read and modify source files with minimal token overhead. The project dropped on GitHub recently and is currently at version 0.1.0, though the developer notes it's already their daily driver editor.

Four-Part Chord System Enables Precise Edits

ane's editing model revolves around a composable chord system with four parts: Action (what to do), Positional (where relative to scope), Scope (which construct to target), and Component (which part of that construct). Commands like "cifc" translate to Change Inside Function Contents, while longer forms like "ChangeInsideFunctionContents(target:foo, value:\"return 0;\")" provide explicit clarity. The system supports scopes ranging from line and buffer operations up through function, variable, struct, and member targetingβ€”but the powerful language-aware constructs require an active LSP connection to work.

Exec Mode Lets Agents Edit Without a Cursor

The real innovation for agent workflows lives in the exec mode. Rather than spinning up a full TUI with cursor state, agents can pipe chord commands directly: ane exec --chord "cifc(target:foo, value:\"new body\")" path/to/file.rs. This headless approach outputs unified diffs to stdout, keeping the token count down compared to traditional approaches that serialize entire editor states. Line and buffer operations work immediately without LSP, while language-aware chords wait for server readiness before executing.

Native LSP Support Across Major Languages

ane auto-detects project languages by scanning for Cargo.toml (Rust), go.mod or go.work (Go), package.json or tsconfig.json (TypeScript/JavaScript), and pyproject.toml or setup.py (Python). It spins up rust-analyzer, gopls, vtsls, and basedpyright respectively, with the TUI status bar showing LSP connection health. The editor gates language-aware chords behind requires_lsp: true flags, ensuring non-LSP operations like line deletion execute immediately while function-targeting changes wait for semantic awareness.

Embeddable Core Enables LLM Tool Integration

For developers building AI coding assistants, ane's Rust library exposes the chord engine and LSP integration without requiring CLI or TUI dependencies. The ane::core::tool_definition() function returns a ready-to-serialize tool definition compatible with Claude, OpenAI, and other LLM APIsβ€”meaning you can wire ane directly into your agent's tool-calling loop without reinventing structured editing logic.

Architecture Maintains Clean Separation

The project enforces a strict three-layer architecture with unidirectional dependencies: Layer 0 handles data (filesystem I/O, state, LSP registry), Layer 1 contains commands (chord parsing, diff generation, LSP client lifecycle), and Layer 2 provides frontends (CLI argument parsing, TUI rendering). Lower layers never import from higher onesβ€”a design choice that keeps the embeddable core clean and predictable regardless of which interface consumes it.

Key Takeaways

  • Ane's chord system combines action/positional/scope/component for expressive, composable edits without traditional verb-noun editing patterns
  • Exec mode outputs unified diffs to stdout, keeping agent token counts low compared to full editor state serialization
  • Native LSP support with auto-detection covers Rust, Go, TypeScript/JavaScript, and Python out of the box
  • The tool_definition() API exposes structured editing capabilities directly to LLMs without TUI overhead

The Bottom Line

Ane isn't trying to replace your vim setup or compete with Zedβ€”it's explicitly experimental infrastructure for AI-native code editing. If you're building coding agents that currently waste tokens wrestling files through prompts, ane's chord engine and headless exec mode might be exactly the surgical tool interface you've been missing.