SoulForge: A Full AI Coding Environment With Live Dependency Graphs and Per-Task Model Routing
We’ve covered a few approaches to giving AI coding agents real codebase awareness recently:
- SocratiCode — a zero-config MCP server that builds a hybrid semantic + BM25 index of your codebase, reducing Claude’s tool calls by 84% on large repos
- GitNexus — pre-computed dependency graphs so agents know blast radius before touching a function
- Understand-Anything — a 5-agent pipeline that builds a visual knowledge graph of your architecture
All three bolt onto existing tools — Claude Code, Cursor, Codex — as plugins or MCP servers. SoulForge is different. It’s a complete AI coding environment that replaces those tools, with graph-based codebase intelligence built into the foundation rather than bolted on.
The Core: Live SQLite Dependency Graph
When SoulForge starts, it builds a dependency graph of your entire codebase and stores it in a local SQLite database. This isn’t a one-time snapshot — it updates in real-time as files change.
What the graph tracks:
- Every file, symbol, import, and export
- PageRank scores — which files are structurally most important in the codebase
- Git co-change history — which files tend to change together (a proxy for hidden coupling)
- Blast radius scoring — how far will an edit in this function ripple?
- Clone detection — duplicate code across the repo
- FTS5 full-text search — fast lexical search across the graph
- Unused export tracking — dead code identification
The agent never reads files to orient itself. It queries the graph. “What’s the most important file in the auth module?” is a PageRank lookup. “What will break if I change this function?” is a blast radius query. The agent starts informed.
Surgical Symbol Extraction
Instead of reading entire files, SoulForge extracts exactly the function or class the agent needs by name. A 500-line file becomes a 20-line symbol extraction.
This is implemented via a 4-tier fallback chain:
- LSP (Language Server Protocol) — most precise, language-aware
- ts-morph — TypeScript-specific deep analysis
- Tree-sitter — fast AST parsing, 33 languages
- Regex — last resort fallback
Dual LSP support: when Neovim is open, SoulForge bridges to the editor’s LSP servers. When it’s not, it runs standalone servers. The agent gets the same quality of code intelligence either way.
This is meaningfully different from how SocratiCode handles reads (semantic search + retrieval) and how GitNexus handles it (pre-built graph queries). SoulForge’s approach is more surgical — it goes to get the specific symbol you need, not the closest contextually relevant chunks.
Multi-Agent Architecture
SoulForge runs parallel agents for explore, code, and web search. When the first agent reads a file, it gets cached — subsequent agents get a compact stub rather than re-reading. Edit coordination prevents conflicts when multiple agents work on overlapping files.
Multi-tab sessions add another layer: each tab can run a different model and mode. Agents see cross-tab edits and get warnings when working on contested files. Git operations coordinate automatically across tabs.
Per-Task Model Routing
This is the cost optimization angle most tools miss. Not every task in a coding session needs the same model:
- Planning — Opus (needs the reasoning depth)
- Coding — Sonnet (fast, capable, reasonable cost)
- Cleanup / formatting / simple edits — Haiku (cheap, fast, sufficient)
SoulForge’s task router assigns models per job. “Spark agents” and “ember agents” each get their own model assignment. The Soul Map (the dependency graph context) is cached and stable across turns — on Anthropic’s API, it hits prompt caching and costs a fraction of re-sending it each time.
The comparison in the repo is direct:
| SoulForge | Claude Code | Aider | |
|---|---|---|---|
| Codebase awareness | Live SQLite graph: PageRank, blast radius, co-change, clone detection | File reads + grep | Tree-sitter + PageRank |
| Cost optimization | Soul Map + surgical reads + instant compaction + model mixing + prompt caching | Auto-compaction | — |
| Code intelligence | 4-tier: LSP / ts-morph / tree-sitter / regex | LSP via plugins | Tree-sitter AST |
| Multi-agent | Parallel dispatch, shared cache, edit coordination | Subagents + Teams | Single |
| Task routing | Per-task model (Opus/Sonnet/Haiku) | — | — |
19 Providers
Anthropic, OpenAI, Google, xAI, Groq, DeepSeek, Mistral, Bedrock, Fireworks, MiniMax, Copilot, GitHub Models, Ollama, LM Studio, OpenRouter, LLM Gateway, Vercel AI Gateway, Proxy, and any OpenAI-compatible endpoint. Local models via Ollama or LM Studio work out of the box.
Embedded Neovim
SoulForge ships with embedded Neovim — your config, plugins, and LSP servers. The AI works through the same editor you use rather than operating in a separate environment. For Vim users this is meaningful; the agent’s edits appear in the same context you’re already working in.
Where It Fits
If you’re happy with Claude Code or Aider, the question is whether the graph-based intelligence and cost optimizations justify switching environments. For large codebases where agents spend significant time on orientation (reading files, grepping, building context), the SQLite graph approach should show real gains — both in speed and in cost.
If you’re already using SocratiCode or GitNexus as MCP plugins for Claude Code, SoulForge represents a more opinionated path: get all of this built in, at the cost of adopting a new environment rather than augmenting your existing one.
Neither path is clearly right. The plugin approach keeps your existing workflow; the integrated approach gets deeper intelligence at the cost of more change. Both are worth knowing about as the space evolves.
MIT license. GitHub →