Built in Rust, it is fast to install (seconds) and remains lightweight under heavy workloads, including multiple sessions, extensive tool usage, and sub-agent execution.

  What's new in 0.9.2:
  - P2P remote access via WebRTC — control your agent from your phone, no port forwarding or cloud relay needed. Just
  `ling login` and scan a QR code.
  - Plan mode — the agent proposes a step-by-step plan before writing code, you approve or edit before execution.
  - Works with any model — Ollama, OpenAI-compatible APIs, Gemini, DeepSeek. Bring your own keys or run fully local.

  It's like Claude Code but model-agnostic, extensible through skills (markdown files), and now accessible from
  anywhere.

  Demo video on the landing page showing install → plan → build → mobile sync.

  Install: curl -fsSL https://linggen.dev/install.sh | bash

  GitHub: https://github.com/linggen/linggen

Comments URL: https://news.ycombinator.com/item?id=47696666

Points: 4

# Comments: 1

  Author here. Built this because I wanted one system where I could drop a markdown file and get a new agent
   — for coding, but also for scheduled code reviews, architecture checks, or anything else.

  The file-based approach is the core idea. An agent is 15 lines of YAML + markdown. A skill is a SKILL.md
  directory. A mission is a cron entry pointing at an agent. No SDKs, no plugins, no code changes — just
  files.

  Happy to go deep on the Rust runtime, multi-agent delegation, or anything else.

  - Multi-agent — agents delegate to each other, run concurrently. Message a running agent mid-task and it
  adapts (cooperative interruption)
  - Any model — Ollama, OpenAI, Claude, Bedrock, any OpenAI-compatible endpoint. Route per agent with
  auto-fallback
  - Skills as files — portable Markdown skills, compatible with Claude Code and Codex (Agent Skills
  standard)
  - Scheduled missions — cron-based autonomous tasks without human-in-the-loop
  - Web UI + TUI + VS Code — all share real-time session state via SSE

  Rust backend (axum, tokio, ratatui). React 19 frontend embedded via rust-embed. Native tool calling for
  all major providers. Workspace-scoped file ops with per-agent permissions.

  Early stage. The name 灵根 (Líng Gēn) means "spiritual root" in cultivation fiction — the innate
  foundation that determines what you can become.



  GitHub: https://github.com/linggen/linggen

  curl -sSL https://linggen.dev/install.sh | bash && ling

Comments URL: https://news.ycombinator.com/item?id=47338489

Points: 2

# Comments: 1

Comments URL: https://news.ycombinator.com/item?id=46706404

Points: 1

# Comments: 1

The tradeoff is simply model quality vs locality, which is why Linggen focuses on controlling retrieval rather than claiming zero data ever leaves the device. Using a local LLM is straightforward if that’s the requirement.

What it can control is the retrieval boundary: what gets selected locally and exposed to the model. If nothing is returned, nothing is sent.

If a strict zero-exfiltration setup is required, then a fully local model would indeed be the right option.

The distinction I’m trying to make is that Linggen itself doesn’t sync or store project data in the cloud; retrieval and indexing stay local, and exposure to the LLM is scoped and intentional.

When using Claude Desktop, it connects to Linggen via a local MCP server (localhost), so indexing and memory stay on-device. The LLM can query that local context, but Linggen doesn’t push your data to the cloud.

Claude’s web UI doesn’t support local MCP today — if it ever does, it would just be a localhost URL.

The key difference is that it works across projects. While working on project A, I can ask: “How does project B send messages?” and have that context retrieved and applied, without manually opening or loading docs.

Linggen is a local-first memory layer that gives AI persistent context across repos, docs, and time. It integrates with Cursor / Zed via MCP and keeps everything on-device.

I built this because I kept re-explaining the same context to AI across multiple projects. Happy to answer any questions.

Working with multiple projects, I got tired of re-explaining our complex multi-node system to LLMs. Documentation helped, but plain text is hard to search without indexing and doesn't work across projects. I built Linggen to solve this.

My Workflow: I use the Linggen VS Code extension to "init my day." It calls the Linggen MCP to load memory instantly. Linggen indexes all my docs like it’s remembering them—it is awesome. One click loads the full architectural context, removing the "cold start" problem.

The Tech:

Local-First: Rust + LanceDB. Code and embeddings stay on your machine. No accounts required.

Team Memory: Index knowledge so teammates' LLMs get context automatically.

Visual Map: See file dependencies and refactor "blast radius."

MCP-Native: Supports Cursor, Zed, and Claude Desktop.

Linggen saves me hours. I’d love to hear how you manage complex system context!

Repo: https://github.com/linggen/linggen Website: https://linggen.dev

Comments URL: https://news.ycombinator.com/item?id=46328769

Points: 36

# Comments: 10