Raggie Code15
languages indexed, plus HTML, CSS, Vue and Svelte
The coding agent that understands large codebases.
Raggie builds a semantic index of your project, traces call graphs and dependencies before it edits, plans work you approve, and hands over to a fresh session when the context window fills up.
< chats
Add input validation to the login endpoint and update all callers
health
dark
Add input validation to the login endpoint and update all callers
The endpoint is probably in the auth module. Find it, then see who calls it before changing its contract.
GetSymbolSourceCode symbol_name: login
WalkCallTree symbol_name: login max_depth: 3
login() is defined in src/auth/views.py and has 3 callers across 2 files. I will validate the email and password fields, then update each caller to handle the new validation error.
EditSymbol symbol_name: login file_path: src/auth/views.py
ReplaceText file_path: src/api/routes.py
Do you want to allow the agent to run:
python -m pytest tests/test_auth.py
allow
always allow
reject
The built-in web UI. The same chat runs in a VS Code sidebar and in the terminal.
32
built-in tools, extensible with MCP servers
16
providers built in, including 7 local model servers
27.8M
lines of the Linux kernel indexed in 10m37s
Coding agents lose more than tokens when context runs out
Most assistants treat a codebase as a pile of text. That breaks down on real projects in three ways.
Dump everything, hope for the best
Whole files go into the prompt as unstructured text. Tokens are spent on irrelevant code, and the part that matters gets drowned out.
Blind to dependencies
Without structure, an assistant cannot tell what calls what or where a change will ripple. It guesses from names and breaks callers it never saw.
Context collapses mid-task
When the limit is hit, history is truncated or summarized. The agent forgets what it changed and why, and long tasks stall or drift.
Built to work on code, not on text
Raggie looks up symbols instead of grepping for strings, shows you the plan before it changes anything, and keeps every change reversible.
index
Semantic code index
Your project is parsed with tree-sitter into functions, classes, imports and the dependencies between them. The agent asks for a symbol and gets exactly that symbol.
graph
Call graphs and blast radius
Before editing, the agent walks the call tree from any function, with cycle detection, to see every caller and callee a change will touch.
frontend
Frontend aware
HTML, CSS, JSX, Vue and Svelte files are indexed into components, markup, selectors, events and bindings, so the agent reads structure instead of raw markup.
plan
Plans you approve
Larger tasks become a todo list with a goal and context per step. Nothing runs until you approve it, and a rejected plan is rebuilt from your feedback.
delegate
Subagents with a depth limit
Each step runs in an isolated subagent with a fresh context window. Thinking modes, from Zen to Insane, set how deep delegation may nest.
handover
Context handover
When the window is nearly full, the agent writes a handover document for the current task and continues in a fresh session. No truncation.
recovery
Crash recovery
Every message is saved as it happens. After a crash or a hard quit, unanswered tool calls are re-run and interrupted subagents resume where they stopped.
undo
Undo and redo
Each turn is snapshotted into a private git repo in .raggie/git, separate from your own. /undo rolls the project back, /redo re-applies.
permissions
You stay in control
Shell commands ask first, unless they are read-only or you whitelisted them. Ignored files and paths outside the project need your explicit permission.
skills
Skills and project rules
Skills are instruction sets loaded on demand, in the Agent Skills format. AGENTS.md holds the conventions that always apply.
health
Code health
After each response Raggie flags the most complex functions and the most bloated classes, scored from the syntax tree. /health writes the full report.
stack
Your model, your tools
Use any OpenAI-compatible model, from DeepSeek and OpenAI to Ollama on your laptop. Add tools from any MCP server, over stdio or HTTP.
One agent, wherever you work
Every interface shares the same chats, index and snapshots, so you can start in the editor and continue in a terminal.
recommended
VS Code
The full chat in a sidebar. The extension installs Raggie and runs the agent for you.
get started raggie code --webWeb UI
Streaming responses, a tool timeline, live subagent view and permission prompts, served by the agent itself.
web UI docs raggie code .Terminal
An interactive chat, or a single prompt with --prompt for scripts.
Zed and ACP editors
Runs as a headless agent over the Agent Client Protocol, with the editor's own approval UI.
ACP docsFrom request to reviewed change
-
Index the project
Files are parsed in parallel with tree-sitter and stored in a local SQLite index. Later runs only re-parse what changed, and the files that depend on it.
-
Explore by structure
The agent reads a file's functions, classes and dependencies, fetches a symbol by name, or walks a call tree. Raw file dumps are the last resort.
-
Plan, and wait for you
For multi-step work it writes a todo list and asks for approval. It can also stop to ask you a question when a requirement is unclear.
-
Execute one task at a time
Tasks run in order, each in its own subagent. Edits go through dedicated tools, and shell commands go through the permission check.
-
Hand over instead of forgetting
If the context fills up mid-task, a handover document carries the request, the changes so far, the errors hit and the exact next step into a new session.
-
Snapshot the result
When the turn ends, the changes are committed to Raggie's private repo and code health is reported. One command undoes it.
How Raggie compares
| Area | Raggie | Typical assistants |
|---|---|---|
| Code understanding | Semantic index, call graphs, dependents and dependencies | Text search and whole-file reads |
| Task planning | Todo lists with an approval gate | None, or an informal plan |
| Full context window | Structured handover to a fresh session | Truncation or summarization |
| Interrupted work | Dangling tool calls and subagents resume | Start the turn again |
| Rollback | Built-in snapshots with /undo and /redo | Your own version control |
| Multi-step execution | Sequential subagents with a depth limit | A single pass |
| Model choice | Any OpenAI-compatible API, including local servers | Often tied to one vendor |
| Data | Index, history and snapshots stay on your machine | Often cloud-hosted |
| Cost | Free and open source. You pay only your model provider | Subscription or per seat |
Get started in minutes
You need Python 3.10+ and an API key for an OpenAI-compatible provider, or a local model server.
recommended
VS Code extension
Install the extension
Search for Raggie Code in the Extensions view.
Open the chat
Click the Raggie icon. The extension installs the
raggiecodepackage and starts the agent.Add your API key
The setup page asks for a key, provider and model. Then start chatting.
terminal and browser
Command line
Install
pip install raggiecodeSet up a key and model
raggie setupStart in your project
raggie code .Or
raggie code --webfor the browser UI.
Frequently asked questions
Does my code get sent to an external API?
Your prompts, the agent's responses and whatever the tools read on the agent's behalf are sent to the LLM provider you configure. The code index, chat history and snapshot repo stay on your machine.
With a local model, nothing leaves it.
Can I use Raggie with a local model?
Yes. Ollama, LM Studio, vLLM, llama.cpp, text-generation-webui, Jan and GPT4All are built-in providers. The model needs to support tool calling. See Local models.
Which providers are supported?
DeepSeek, OpenAI, z.ai, Grok, Qwen, Moonshot (Kimi), OpenCode Go and Zen, LiteLLM, and the local servers. Anything else that speaks the OpenAI Chat Completions API works through a custom base URL.
Raggie handles the differences between providers for you, such as how reasoning is switched on and passed back. See Configuration.
Which programming languages does Raggie index?
Python, Go, C#, JavaScript, TypeScript, TSX, Rust, Zig, Elixir, C, C++, PHP, Dart, Java and Kotlin, through tree-sitter grammars. HTML, CSS, Vue and Svelte files are indexed as frontend structure.
Files in other languages can still be read, searched and edited. They just are not part of the call graph. See Code indexing.
What happens when the context window fills up?
The agent writes a handover document for the task it is working on: your latest request, what has changed so far, the files and symbols involved, errors and failed attempts, and the exact next step. It then continues in a fresh session seeded with that document.
See Context handover.
What happens if I interrupt the agent or it crashes?
Nothing is lost. Messages are saved as they happen. When you reopen the chat, unanswered tool calls are re-run and the turn continues. Subagents and todo tasks resume their existing sessions instead of starting over, and unfinished todo lists are offered for resumption.
How do I control what the agent can touch?
Files matched by .aiignore (or .gitignore when there is no .aiignore) are never indexed and need your explicit permission to read or change. So do paths outside the project.
Shell commands ask before running unless they are read-only or you approved them with "always". See Permissions.
Does Raggie commit to my git repository?
No. Snapshots go to a separate repository in .raggie/git. Your project's own .git is never read or written. /undo and /redo work on those snapshots.
Where is my data stored?
Per project, in a .raggie/ folder in the project root: the chat database, the code index, the snapshot repo and per-chat locks. Per user, in ~/.config/raggie/: API keys, roles, tool definitions and MCP servers.
Can I use Raggie in my editor?
Yes. The VS Code extension gives you the chat in a sidebar and installs Raggie for you. Zed and other editors that speak the Agent Client Protocol can launch it with raggie --acp-stdio. Any browser works with raggie code --web.
Can I extend Raggie with external tools?
Yes, through MCP. Add a server with raggie mcp --add and its tools appear to the agent next to the built-in ones. Both stdio and Streamable HTTP servers are supported. See MCP.
Can I customize the agent's behavior?
Put project conventions in an AGENTS.md file in the project root. Add skills for instructions that should load only when needed. Change the model, tools and system prompt per role in roles.json.
More answers in the docs FAQ.
Give your agent a real understanding of your code.
Free, open source, and your index and history never leave your machine.