SajiCode — An autonomous engineering organism

Inspiration

Single-agent coding tools like Claude Code are powerful but they still behave like one contractor waiting for instructions: you prompt, review, prompt again, fix mistakes, and repeat.

Real software teams don’t work that way. A PM researches and plans. Specialists own their domains. Contracts are agreed before code is written. QA verifies before anything ships. Memory persists across days and weeks.

We asked: What if we automated the entire engineering workflow not just the typing?

That question became SajiCode: a multi-agent autonomous system that researches, plans, locks contracts, executes in parallel, verifies, and learns running on your machine, your models, and your infrastructure.

What it does

SajiCode is not a chat wrapper around one model. It is an autonomous engineering organism:

PM orchestrator — researches, plans, and coordinates; never writes implementation code 17 specialist agents — Backend, Frontend, QA, Security, Deploy, and more — each with enforced file territories Contract-first protocol (Phase 0) — APIs, types, and ownership locked before any agent writes code Three-layer memory + PROJECT.dna — architecture and decisions survive across sessions Tree-sitter code graph + semantic retrieval — navigate large repos without blowing the context window Git-native safety — per-agent snapshots, rollback, pre-write scans 24/7 daemon — heartbeat, durable task queue, sleep-time consolidation Guardian Swarm — tiered defensive monitoring + incident knowledge graph Headless CI mode — fix-ci pulls failed logs and attempts repairs autonomously Describe a task once. The team plans it, builds it in parallel, tests it, and updates project memory — local (Ollama), cloud, or air-gapped.

npm install -g sajicode sajicode build "REST API with auth, tests, Docker, and CI"

How we built it

We built SajiCode on LangGraph + LangChain DeepAgents for durable, stateful multi-agent orchestration.

Architecture highlights:

Contract-first parallel execution — PM creates Phase 0 contracts; independent leads run in parallel without stepping on each other Territory guardrails — middleware-level enforcement (not prompt-only) blocks agents from writing outside their domain Per-agent context isolation — each specialist gets scoped context so one bloated thread doesn’t poison the whole team Three-layer memory — short-term session state, semantic long-term memory, and PROJECT.dna for durable project knowledge Tree-sitter AST code graph — PageRank-ranked retrieval for TypeScript, JavaScript, Python, and Go Verification ladder — typecheck → tests → smoke → optional E2E before ship MCP + A2A interoperability — plug into external tools and other agent systems The CLI streams live output from every agent — so you can watch the whole team work, not just read a final answer.

Stack: Node.js · TypeScript · LangGraph · LangChain · Tree-sitter · Express (serve mode) · Docker / Modal / Daytona backends

Challenges we ran into

1. Multi-agent coordination without chaos When many agents share one context, they overwrite each other, duplicate work, or hallucinate conflicting APIs. We solved this with Phase 0 contracts, territory enforcement, and a PM that never writes code.

2. Context limits on real codebases Long repos break single-thread agents. We added a Tree-sitter code graph, semantic search, and scoped per-agent briefings so agents query structure instead of stuffing tokens.

3. Amnesia across sessions Agents forget everything when the session ends. Our three-layer memory system and PROJECT.dna persist architecture, decisions, and unfinished work.

4. Trust and safety Autonomous agents can damage a repo fast. We built git-native revert-per-agent, pre-write security scans, human-in-the-loop gates, and a Guardian Swarm for defensive monitoring.

Accomplishments that we're proud of

Built a full multi-agent engineering team in open source — not a demo script 17 agents with real roles, territories, and parallel execution Contract-first workflow that mirrors how production teams actually ship Persistent memory that compounds across sessions Autonomous modes — headless build, fix-ci, and 24/7 daemon Provider-agnostic — works with OpenAI, Anthropic, Google, Ollama (local/air-gapped) MIT licensed and published on npm: sajicode We set out to reduce human babysitting in AI-assisted development — and shipped a system that can plan, build, verify, and remember with minimal intervention.

What we learned

The harness is the product. Model choice matters less than orchestration, memory, guardrails, and verification.

Giving AI the right tools (git, tests, contracts, code graph, MCP) plus hard guardrails (territories, rollback, verification ladder) turns a chatbot into something that behaves like an engineering org.

Multi-agent systems fail without boundaries. Single-agent systems fail without memory. SajiCode was our answer to both.

What's next for SajiCode

SajiCode is in beta. Next up:

SajiCode Studio (Web UI) — live multi-agent streaming, rendered plans/architecture docs, in-browser preview, terminal, and one-click deploy Hosted sandboxes — Docker/Fly workspaces so anyone can build without a laptop Open-core model — CLI and engine stay open source; hosted studio and team features power sustainability Vision: The first platform where you watch an entire engineering team build, test, and deploy your app — in the browser or on your machine.

Built With

• deepagent
• langchain
• langgraph
• typescript