Code stays local.AI understands
Terminal-first
developer AI.
A local-first REPL that understands your repository, remembers across sessions, and routes intelligently to the right model for the task. Built for developers who want AI that stays under their control.
Persistent REPL Session
Launch once with `velune` and stay inside. Ask questions directly, use slash commands like `/run`, `/model`, and `/optimus`, or pick from interactive menus. Your session never drops.
Codebase Understanding
Velune maps how your project connects — functions, modules, and dependencies. Ask high-level questions about your architecture, not just which file contains what.
Memory Across Sessions
Five memory tiers — working, episodic, semantic, graph, and lineage — carry decisions, patterns, and architectural context forward across days and weeks.
Any Model, One CLI
Run locally with Ollama, LM Studio, or any OpenAI-compatible server, or route to OpenAI, Anthropic, Gemini, Groq, and more. Switch with a single command. Credentials stay on your machine.
Install.Launch.Work.
Install
in secondsInstall Velune as a Python package. Supports Ollama (local), OpenAI, Anthropic, or any provider. Credentials stored securely in OS keyring.
Launch
the REPLStart the persistent REPL session. Direct prompts or slash commands. Arrow-key navigation, interactive pickers, live streaming.
Work
interactivelyAsk questions, use /run for autonomous tasks (Phase 2+), adjust with /optimus (fast) or /godly (powerful). Your memory persists.
See it
work.
Install, init, and run. Five specialised agents review your task from every angle — planning, writing, reviewing, challenging, and synthesising — before anything is shipped.
Connect
everything.
Route to OpenAI, Anthropic, Groq, xAI, Gemini, and more, or run locally with Ollama. Understand your codebase via GitHub or GitLab. Connect Docker, Postgres, MySQL, and Supabase as live resources. All in one CLI.
Privacy by
default.
Runs locally by default
Velune works entirely on your machine out of the box. Cloud providers are available when you need them, but never required.
Remembers across sessions
Velune builds up knowledge of your project over time — past decisions, recurring patterns, and architectural context that carries forward.
No lock-in, ever
Start with local models, switch to any cloud provider, and switch back — same CLI, same memory, no configuration rewrites.
Principled
from the ground up.
Velune is built on four non-negotiables: your code stays on your machine by default, you are never locked into one AI provider, every change is previewed before it happens, and the roadmap is honest about what exists today versus what is coming.
Private by default
Runs locally on your machine. Your code never leaves unless you choose to route to a cloud provider. Credentials are stored securely in your OS keyring.
Understands your project
Velune maps your codebase structure — not just text. It knows how things connect, so it can reason about the impact of any change before acting.
Always shows the diff
Before any file is changed, Velune shows exactly what it wants to do. Review line by line, accept or reject. One command to roll back.
No lock-in, ever
Start with Ollama locally, move to OpenAI, switch to Anthropic — same CLI, same memory, same session. Change your mind anytime.
Building in public — the journey.
Every great tool starts with a foundation you can trust. We got the async runtime, streaming, and security model right before building anything on top of it — then shipped the reliable REPL core.
Built in
the open.
Velune is actively developed, currently at v0.9.6. Here's what's shipped, and what we're converging toward for v1.0.
Reliable Foundation
REPL, streaming, model routing
- Persistent REPL — launch once, stay inside
- Live streaming responses across 17 local and cloud providers
- Conversation memory that carries context through your session
- Automatic model selection based on task type
- /run for autonomous task execution
- /model to switch AI providers interactively
- Speed modes: /optimus (fast), /normal, and /godly (max power)
- Session history stored locally on your machine
Repository Cognition
Codebase mapping, 5-tier memory, resource connectors
- AST-based repository indexing and a queryable knowledge graph
- Incremental cognition — delta-aware reindexing, 32–130x faster warm turns
- 5-tier memory: working, episodic, semantic, graph, and lineage
- Hybrid retrieval — BM25 + vector + graph, cross-encoder reranked
- Blast-radius impact analysis before any code change
- Resource connectors: Docker, Postgres, MySQL, Supabase (approval-gated)
- Unified backup, restore, and crash recovery for all local state
Council & Convergence
Multi-agent council, git/MCP integration, full REPL wiring
- Council mode live: Planner, Coder, Reviewer, Challenger, Synthesizer
- /run and /council route every complex task through the full council
- Native tool-calling loop wired end-to-end into the REPL
- Git integration — /push, /pr, /issue against GitHub and GitLab
- MCP server and client — stdio, SSE, HTTP, and WebSocket transports
- Declarative plugin system with SKILL.md injection
- velune context / velune trace for repository-cognition observability
- Continued hardening toward a stable v1.0 release