Research & investigation agent
Reason at project, flow, subflow, or node scope using the graph, local files, documents, web research, durable memory, and subagents.
Open source · AGPL-3.0 · macOS / Windows / Linux
The architecture graph is the living source of truth
ArchiCode is a graph-native software engineering harness for investigating, researching, planning, building, debugging, and evolving software with AI agents — with every decision, diff, and verification connected to a durable architecture model your whole team works from.
Why ArchiCode
AI writes code faster than you can reconstruct the intent behind it
In the agentic era every team can generate more code than it can honestly review. The bottleneck isn't writing anymore — it's knowing what you have, why it's there, and whether you can still trust it.
Files expose details, chat captures a moment
Traditional IDEs are file-first and agent harnesses are chat-first. Neither gives you the durable big picture needed to supervise a large, continuously changing AI-built system.
The graph is the working contract
ArchiCode connects architecture, design flows, code evidence, decisions, implementation scope, and verification state in one observable workspace shared by engineers and agents.
A complete harness, not a layer
ArchiCode doesn't wrap another tool's harness. Codex, Claude, and compatible APIs are interchangeable model sources — the harness itself, with its persistent context, orchestration, observability, and human review, is ArchiCode.
The core loop
One connected engineering cycle
Move from a system-level view down to a source relationship — and follow every run, diff, test, failure, and approval back to the graph.
Start a project from scratch or import an existing codebase into evidence-backed architecture perspectives.
See it in action 
From eagle view to source evidence
Model components, features, tasks, groups, dependencies, and nested detail flows on an editable architecture canvas.
What it means for you
Ease of mind in the agentic coding era
Chat-first and code-first tools are great at producing change — and terrible at helping you live with it. ArchiCode gives you a place to stand: a truthful map of the system, and professional-grade control over everything the agents do to it.
Truthful
Every node and edge traces back to real files, symbols, and calls — the graph can't quietly drift away from the code it describes.
Familiar
Architecture diagrams are how engineers already think. ArchiCode keeps that language — but makes it live, versioned, and verifiable.
In control
Plans, diffs, tests, failures, verification evidence, token spend — observable end to end, with human approval exactly where it matters.
Highlights
Everything the loop needs, in one workspace
AI build harness
Turn an approved direction into scoped planning, source changes, tests, debugging, verification, artifacts, and human review.
Graph as living source of truth
Keep architecture intent, implementation evidence, decisions, status, and acceptance checks in one shared model.
End-to-end observability
Inspect queues, plans, tool activity, traces, logs, diffs, failures, verification evidence, token usage, and review decisions.
Evidence-backed codebase maps
Import an existing repository into architecture perspectives backed by real files, symbols, imports, calls, and source locations.
Editable 2D architecture canvas
Model components, features, tasks, settings, groups, dependencies, and nested detail flows.
Multi-layer 3D exploration
Navigate root flows and nested architecture layers without losing their spatial relationship.
Code and graph resync
Reconcile architecture after external edits using deterministic, affected-scope updates and auditable reports.
Acceptance & policy checks
Attach executable criteria to architecture nodes and surface deterministic architecture-policy findings.
Local-first project memory
Portable planning state lives under .archicode/ while
credentials and runtime data stay machine-local.
Provider & tool choice
Use Codex or Claude locally, OpenAI-compatible or Anthropic-compatible APIs, project skills, and MCP servers.
Practical project tooling
Browse files, inspect diffs, operate Git, run local services, debug failures, and export diagrams or project data.
Built for teams
Collaboration between engineers — not just you and an agent
The same graph that keeps agents grounded keeps a team aligned. Architecture, decisions, and verification state become shared, versioned knowledge instead of tribal memory.
One graph, whole team
Architecture intent, decisions, status, and acceptance checks live in a model every engineer can see — not in one person's head or a private chat transcript.
Git-friendly project memory
Portable planning state under .archicode/ is readable and
versioned with the repo, so flows, decisions, and ledgers travel through
normal branches, reviews, and merges.
Onboard in the eagle view
New teammates start from evidence-backed architecture maps and functional communities instead of spelunking through files to reconstruct the system.
Reviews everyone can see
Agent work lands as explicit proposals, diffs, tests, and verification evidence — so review decisions stay visible to the whole team, not siloed in someone's session.
Open source
Free, auditable, and built in the open
ArchiCode is released under the GNU Affero General Public License v3
(AGPL-3.0-only). Use it, modify it, and distribute it —
subject to the AGPL's source-availability and network-use terms. A
separate commercial license is available for organizations that need
different terms, including closed-source distribution.
Run it locally
Requires Node.js 22.12+ and npm.
git clone https://github.com/roymasad/ArchiCode.git
cd ArchiCode
npm install
npm run devDesktop builds for macOS, Windows, and Linux are on the releases page.
Give your AI agents an architecture they can't forget
Start a new project from the graph up, or import an existing codebase — get the eagle view and supervise AI-built change with confidence.