Julie - Code Intelligence for AI Agents

Token Savings

Measured across real projects (Rust, TypeScript, Python, JavaScript). Same tasks. Dramatically less context consumed.

Task	Without Julie	With Julie	Savings
Understand a file's API	~3,000 tokens	~300 tokens	~90%
Find a function definition	~4,000+ tokens	~100 tokens	~97%
Investigate before modifying	~5,000+ tokens	~200 tokens	~96%
Orient on new area	~10,000+ tokens	~800 tokens	~92%
Edit a function	~3,000+ tokens	~500 tokens	~80%

How It Works

Julie keeps a compact code map ready so agents can ask better questions before they spend your context.

🌳

Step 1

Parse

Map symbols, relationships, tests, and types across 34 languages

📦

Step 2

Index

Keep search, graph, and semantic context ready for the workspace

⚡

Step 3

Query

Return focused answers, previews, impact, and likely tests

Built for Agent Workflows

Julie is useful when an agent needs to move fast without pretending it read the whole repository.

Find the right code

Search by concept, symbol, or file path and get ranked results with enough context to choose the next move.

Understand before editing

Inspect callers, callees, types, and nearby tests before touching the implementation.

Preview risky changes

Rewrite, edit, and rename with dry-run diffs so the agent can show its work before applying it.

Know what to test

See likely affected symbols and tests before a change turns into a guessing exercise.

Reference Graph

Julie does not just find symbols. It shows how they connect.

$ deep_dive("process_payment", overview)

→ Callers: handle_checkout, retry_payment, batch_processor

→ Callees: validate_card, charge_gateway, emit_event

→ Types: PaymentRequest → PaymentResult

→ ~400 tokens. Zero file reads.

One call. Full picture. Zero file reads.

Test Intelligence

Every test rated by quality. Know which tests actually protect your code.

// Test Quality Analysis

Tests: 3 found

✓ test_process_payment (thorough, 8 assertions, error paths)

✓ test_payment_validation (adequate, 4 assertions)

○ test_payment_retry (thin, 1 assertion, no error paths)

Computed at index time. Every test scored automatically.

Skills

A focused set of pre-built workflows that combine Julie's tools into higher-level capabilities.

/editing

Zero-read editing: understand and modify without reading files

$ /editing

deep_dive → rewrite_symbol (dry_run)

@@ -42,5 +42,5 @@

-fn validate(t: &str) -> bool

+fn validate(t: &str) -> Result

/explore-area

Token-budgeted orientation on an unfamiliar area

$ /explore-area auth flow

get_context → 6 pivots, 14 neighbors

Budget used: 812 / 1500 tokens

→ AuthService::login is the entry point

/impact-analysis

Blast radius for a symbol, with callers grouped by risk

$ /impact-analysis User::email

blast_radius → 47 impacted symbols

High risk: 3 · Medium: 11 · Low: 33

Likely tests: auth_tests.rs · user_api.rs

→ Review handler.rs and login_flow.rs first

/web-research

Fetch web content, index it locally, and read only the useful sections

$ /web-research rust async docs

browser39 fetch → local markdown

fast_search → matching sections

→ Read the docs without dumping the whole page

Semantic Embeddings

Find what you mean, not just what you typed.

// Keyword Search

$ fast_search("handle user login")

→ handle_user_login (exact match)

→ login_handler (partial match)

// Semantic Similarity

$ deep_dive("authenticate") → Related:

→ verify_credentials (0.92 similarity)

→ validate_session (0.87 similarity)

→ check_permissions (0.81 similarity)

GPU-accelerated embeddings. Works with CUDA, MPS, and DirectML. Falls back to CPU gracefully.

Tools

12 focused tools. Each one replaces scattershot file reads.

fast_search

Full-text code search with code-aware tokenization

$ fast_search("UserService", definitions)

Definition found: UserService

src/services.rs:42 (struct, public)

3ms

~150 tokens

get_context

Token-budgeted context for a concept or task

$ get_context("payment processing")

Pivots (3): process_payment, PaymentService, charge_gateway

Neighbors (8): signatures + types

Token budget: 2000 · Used: 1847

~1,000 tokens

deep_dive

Progressive-depth symbol investigation

$ deep_dive("process_payment", overview)

Callers (3) · Callees (3) · Types (2)

Centrality: 0.82

~400 tokens

fast_refs

Find all references to a symbol

$ fast_refs("UserService")

12 references across 8 files

api.rs:15, handler.rs:42, tests.rs:8, ...

~400 tokens

get_symbols

Smart file reading with 70-90% token savings

$ get_symbols("src/services.rs", structure)

struct UserService (pub)

fn new() → Self

fn authenticate(&self, ...) → Result

500 lines → 20 line overview

~150 tokens

edit_file

Edit files without reading them first

$ edit_file("src/auth.rs", old_text, new_text, dry_run)

@@ -42,5 +42,5 @@

-fn validate(token: &str) -> bool {

+fn validate(token: &str) -> Result<Claims> {

Fuzzy matched (trimmed-line)

~200 tokens

rewrite_symbol

Rewrite one live symbol span without reading the file first

$ rewrite_symbol("AuthService::validate", replace_body, "{ return validate_claims(token)?; }", dry_run)

@@ -43,3 +43,5 @@

- return false;

+ return validate_claims(token)?;

Live symbol span from src/auth.rs:42

~250 tokens

rename_symbol

Workspace-wide rename with dry-run preview

$ rename_symbol("UserService", "AccountService", dry_run)

Preview: 15 files, 23 replacements

services.rs:42 UserService → AccountService

handler.rs:15 UserService → AccountService

~500 tokens

manage_workspace

Index, add, remove, refresh workspaces

$ manage_workspace(index)

Indexed: 1,247 symbols from 89 files

Languages: Rust, TypeScript, Python

1.8s

~100 tokens

blast_radius

Impact analysis for changed files, internal symbol IDs, or revisions

$ julie-server blast-radius --files src/auth/login_flow.rs

47 impacted symbols

High: login_flow.rs:LoginHandler::handle

Tests: auth_tests.rs, session_api.rs

spillover_handle=br_a1b2 (23 more)

~400 tokens

call_path

One shortest call-graph path between two symbols

$ julie-server call-path "LoginButton::onClick" "insert_session"

found: true hops: 2

onClick → AuthService::login

AuthService::login → insert_session

~180 tokens

spillover_get

Fetch the next page from a saved overflow handle

$ spillover_get("br_a1b2")

Impact overflow

11. AuthService::refresh

More available: spillover_handle=br_c3d4

~120 tokens

34 Languages

Broad symbol extraction, test detection, and relationship coverage, tracked by explicit capability checks.

Core (12)

Rust TypeScript JavaScript Python Java C# VB.NET PHP Ruby Swift Kotlin Scala

Systems (5)

C C++ Go Lua Zig

Functional (1)

Elixir

Specialized (12)

GDScript Vue QML R Razor SQL HTML CSS Regex Bash PowerShell Dart

Documentation (4)

Markdown JSON TOML YAML

<5ms

Search

<100MB

Memory

<2s

Startup

After initial indexing, only changed files are re-processed, keeping your index fresh in seconds, not minutes.

Observatory Dashboard

A built-in dashboard for seeing how Julie is helping across workspaces.

Intelligence

Codebase analytics: important symbols, file hotspots, language mix, and project story cards

Top Symbols

1. process_payment fn (0.92)

2. UserService struct (0.87)

3. handle_request fn (0.81)

Search Playground

Try searches across indexed workspaces and see why results ranked where they did

$ search "authenticate"

verify_credentials score: 42.1

validate_session score: 38.7

2 workspaces searched

Projects

Workspace overview with language distribution, symbol counts, and indexing status

my-app Ready

1,247 symbols | 89 files

Metrics

Tool performance, failed calls, edit efficiency, and bytes kept out of context

Bytes not injected: 1.2MB

Failed calls: 1.1%

Edit dry-runs: 38

Your MCP client launches julie-server directly. Run julie-server dashboard or manage_workspace(operation="dashboard") to explore the local dashboard.

Installation

Use the Claude Code plugin for the full experience, or wire the plugin launcher or binary into any MCP client.

# Install the plugin (recommended)

$ /plugin marketplace add anortham/julie-plugin

$ /plugin install julie@julie-plugin

// .vscode/mcp.json

{

"servers": {

"Julie": {

"type": "stdio",

"command": "/path/to/julie-server"

}

// opencode.json

{

"mcp": {

"julie": {

"type": "local",

"command": ["node", "/path/to/julie-plugin/hooks/run.cjs"],

"enabled": true

}

// .cursor/mcp.json or compatible MCP config

{

"mcpServers": {

"julie": {

"command": "/path/to/julie-server"

}

# GEMINI.md (project root)

# Julie MCP server is configured separately

# in ~/.gemini/settings.json

# Add to ~/.gemini/settings.json:

{

"mcpServers": {

"julie": {

"command": "/path/to/julie-server"

}

# ~/.codex/config.toml

[mcp_servers.julie]

command = "node"

args = ["/path/to/julie-plugin/hooks/run.cjs"]

Julie indexes your workspace automatically on first connection or first primary tool call. Some clients need an explicit workspace path; the README has the per-client details.