Capabilities

Built for how
developers actually work

aricode isn't another autocomplete. It's an autonomous agent that understands your codebase, remembers what it learns, and gets smarter every session.

Autonomous Exploration

It dreams while you sleep

Start a dream session before you leave for the night. aricode explores your entire codebase autonomously — mapping architecture, finding patterns, spotting issues, and imagining where the code could go next. When you return, it has a full journal waiting.

Light Sleep

Survey & Triage

aricode reads through your project with fresh eyes. It maps entry points, traces module boundaries, spots naming inconsistencies, flags dead code, and builds a mental picture of how everything connects. Then it ranks what's worth investigating further.

REM

Deep Dive & Futures

The interesting threads get pulled. aricode follows each question down the rabbit hole — tracing call chains, reading test coverage, understanding why things were built the way they were. Then it imagines where the code could evolve: what new features would fit naturally, what refactors would pay off, what's one bad merge away from breaking.

Deep Sleep

Synthesis

Everything crystallizes. aricode writes a dream journal — a first-person narrative of what it found, what surprised it, and what it recommends. It also extracts patterns, antipatterns, conventions, gotchas, and a living schema of your codebase that persists into future sessions.

What you get back
journal Dream journal with findings and recommendations
tree Futures tree mapping where your code could go
patterns Extracted patterns, antipatterns, and conventions
schema Living architecture schema of your codebase
Memory

A codebase that
remembers itself

Most AI tools forget everything between sessions. aricode builds a persistent knowledge graph — a map of every file, function, import, and relationship in your project. It updates incrementally, so it only re-reads what actually changed.

  • Files & symbols — tracks every function, class, and constant with line numbers, signatures, and git history
  • Relationships — maps imports, function calls, inheritance chains, and type references
  • Semantic concepts — extracts higher-level patterns the model discovers during exploration
  • Incremental updates — uses content hashing and git diffs to only re-index what changed
auth.ts
router.ts
validateToken()
handleRequest()
middleware.ts
auth flow
Intelligence

It reads test failures
like a developer would

When tests fail, most tools dump raw output. aricode compiles failures into behavioral specifications — structured descriptions of what each function is supposed to do, not just what went wrong.

  • Test witnesses — each failing assertion becomes a specification: "this function should transform A into B"
  • Root cause analysis — uses the dependency graph to identify which function, if fixed, would resolve the most failures
  • Progress tracking — across fix iterations, tracks which witnesses are resolved, which regressed, and whether the overall trajectory is improving
  • Framework support — understands TAP, pytest, and unittest output natively
witness
formatPhone('(415)555-0100')
'+14155550100'
witness
validateEmail('')
throw InvalidInput
resolved
parseDate('2024-01-15')
Date(2024,0,15)
Precision

Every edit is analyzed
before it lands

aricode doesn't just write code and hope for the best. Every change triggers a post-edit pipeline: linting, convention checks, dependency analysis, and blast radius reporting. It catches problems before they become commits.

  • Automatic linting — runs your project's linter (ESLint, Pyright, clippy) on every edited file
  • Convention matching — learns your naming patterns, import style, and file structure, then flags inconsistencies
  • Blast radius — traces the dependency graph to show what other code might be affected by the change
  • Knowledge graph refresh — immediately re-indexes edited files so the next action has up-to-date context
Edit detected
Lint & format
Convention check
Blast radius
Graph updated
Trust

Safe by default,
not by promise

Every command aricode runs goes through a three-tier security gate. Read-only operations pass automatically. Mutations need your consent. Dangerous operations are blocked entirely. Your API keys and secrets are stripped from the environment before any command executes.

  • Readonly tier — cat, grep, git status, ls: auto-approved, no prompt needed
  • Mutating tier — npm test, git commit, make: requires your consent first
  • Privileged tier — npm install, git push, curl: explicit opt-in required
  • Environment sanitization — API keys, tokens, SSH keys, and secrets are stripped from every subprocess
auto
Readonly
grep, cat, find, git status
consent
Mutating
npm test, git commit, make
opt-in
Privileged
npm install, git push, curl
blocked
Forbidden
rm -rf, sudo, eval, chmod
And more

Everything else
that makes it click

Subagent Orchestration

For complex multi-file tasks, aricode spawns dedicated subagents — each with its own conversation and tool access, coordinated by the parent. Subagents can read but not write, keeping edits under the main agent's control.

Hooks System

Wire your own automation into aricode's lifecycle. Run formatters after edits, linters before commands, or setup scripts on session start. Six hook points, shell-based, zero config beyond a JSON file.

Local-First

Run entirely on your machine with Ollama. No cloud, no API key, no data leaving your network. Or connect to any OpenAI-compatible endpoint — cloud providers, self-hosted stacks, or local inference servers.

Model-Agnostic

Switch models by changing one environment variable. Works with Claude, GPT-4, Gemini, DeepSeek, Qwen, Llama, Mistral, and anything that speaks the OpenAI chat completions protocol. Use a fast model for daily work and a thorough one for dreaming.

Ready to try it?

$ curl -fsSL https://install.aricode.dev | sh

Read the docs or follow the project on GitHub — source drops at v1.