Personal IDE — Agentic Development Environment

An autonomous agentic IDE where agents never read raw code. Every structural
element is a devtag. Every plan element is a plantag. Every edit
operation is a buildtag. The system improves itself.

What This Is

Personal IDE is a fully self-modifying, agent-driven development environment built on a unified tag language. It operates across two concurrent layers:

Build Layer — Runs build cycles: pre-edit crawls, Waiting state, Skeptic refinement, Command voting, Builder execution, post-commit validation.

Meta Layer — Runs persistently: the Blame Crawler attributes outputs to models, Gap Analysis identifies systemic failures, the Suggested Jobs system generates improvement work, and THE GOD FACTORY Agent synthesizes everything into a conversational self-improvement loop.

These two layers share one forensic database, one tag registry, and one agent authority system.

Quick Start

Prerequisites

Setup

Windows (PowerShell):

git clone https://github.com/Ileices/personal_IDE.git
cd personal_IDE
.\setup.ps1

Linux / macOS:

git clone https://github.com/Ileices/personal_IDE.git
cd personal_IDE
chmod +x setup.sh && ./setup.sh

Or manually:

git clone https://github.com/Ileices/personal_IDE.git
cd personal_IDE
pnpm install              # install all dependencies
pnpm --filter @personal-ide/shared build   # build the shared types package
cp .env.example .env      # then edit .env and add your GITHUB_PAT

Run

npm run dev

This starts:

• Server at http://localhost:3001 (Fastify + API routes)
• Frontend at http://localhost:5173 (React + Vite)

Open http://localhost:5173 in your browser.

Architecture

personal_IDE/
├── apps/
│   ├── server/          # Fastify backend — chat, models, memory, agent, nano control
│   └── web/             # React frontend — Vite, Tailwind, Monaco editor
├── packages/
│   └── shared/          # Shared TypeScript types & constants (compiled to dist/)
├── NANO_train/          # Sea of Nanos — Python ML backend
│   ├── main.py          # Boot sequence (10 steps)
│   ├── core/            # Foundation nanos
│   ├── nanos/           # 296 specialized nanos (19 categories)
│   ├── mesh/            # P2P networking, global pool, peer discovery
│   ├── server/          # FastAPI backend (port 5100)
│   ├── training/        # Training pipeline
│   └── scanner/         # AE filesystem scanner
├── scripts/
│   └── setup.js         # Cross-platform setup script
├── setup.sh             # Unix setup wrapper
├── setup.ps1            # Windows setup wrapper
└── .env.example         # Environment template

Key packages

The Tag System

Agents never read raw code. Every structural element is represented as a tag, resolved through a deterministic tool call.

Three Tag Types

A buildtag is invalid unless it references at least one existing devtag and at least one unfulfilled plantag.

Tag Families

• Base vocabulary — module, class, function, method, import, route, schema, component, service, test, and 70+ more
• Relationship tags — calls, inherits, implements, composes, depends_on, subscribes_to, publishes, reads_from, writes_to
• Nano Sea tags — nano:module, nano:layer, nano:node, nano:weight:frozen, nano:weight:personal, nano:cycle
• Attribution tags — agent_generated, human_generated, last_modified_by, created_by, reviewed_by
• Performance tags — perf_critical, memory_bound, hot_path, latency_sensitive, cpu_bound
• Versioning tags — version, deprecated, breaking_change, stable, legacy, public_api
• Status markers — needs_rollback, needs_refactor, needs_test, dead_code, orphaned

Tag Registry Service

resolve_devtag(tag)   // → file, line range, parent, relationships, content hash
resolve_plantag(tag)  // → status, requires[], produces[], milestone, estimate
resolve_buildtag(tag) // → operation type, source devtag, target devtag, status

The full tag chart is a tool call, not a prompt. Zero context tokens consumed.

The God Factory Screen

Primary interface. All panels are collapsible in the right sidebar.

Chat Agent Tools (31 available)

The God Factory chat agent has direct access to every system API:

# Codebase tools
list_files, read_file, search_code, get_docs, patch_file, write_file, run_command

# God Factory system
get_notification_queue, get_idle_suggestions, create_brainstorm_job

# Suggested Jobs
find_suggested_jobs, get_job_detail, read_sandbox_status, implementation_pipeline_status

# Forensic tools
read_forensic_entries, read_blame_records, regression_index

# Live analysis
live_debt_check, live_coverage_check, live_pattern_query, debt_heatmap, pattern_trend

# Tag system
inspect_devtag, resolve_devtag, tag_vocabulary_diff, orphan_scan, conflict_scan

# Gap analysis
gap_scan, agent_conformance_report

# Authority
spawn_authority_check

Build Pipeline

Pre-Edit Protocol (mandatory before every edit)

Three sub-agents run concurrently. No edit begins until all three deliver outputs to WAITING state:

1. Memory Crawler — All accessible memory → compact devtag database
2. Project Description Crawler — All project files → plantag database
3. Project State Crawler — Actual files on disk → ground truth devtag snapshot + drift events

State Machine

CRAWLING → TAG_GENERATION → REFINING → VOTING → SENT_TO_COMMAND

Skeptic Agent refinement: max 5 iterations. Tie votes → Command Agent at weight 1.5. God Factory holds absolute veto.

Post-Commit Sequence (in order, mandatory)

1. Integration Verification Sub-Agent
2. Regression Sub-Agent
3. Version Control Agent
4. Coverage Analysis Agent
5. Blame Crawler (async)

Implementation Pipeline (6 Stages)

1. Pre-Implementation Scan — Ground truth vs sandbox drift check
2. Backup — Version Control rollback point tagged with job_id
3. Staged Rollout — One atomic step at a time, full pre-edit protocol each
4. Live Testing — Full test suite against real codebase
5. Stability Check — 10-cycle monitoring window, auto rollback on crash
6. Completion — Job marked implemented, commits tagged, plantags done

Blame Crawler

Every model output produces a blame record. No output is unattributed. The output capture layer introduces zero latency.

Quality dimensions (composite score = weighted average):

Composite score < 0.65 for 3 consecutive outputs → Tool Criticism sub-agent activates, generates improvements forwarded to Suggested Jobs.

Gap Analysis System

Persistent systemic analysis across all cycles, agents, forensic history, and sessions. Five gap categories: coverage, structural, process, tag system, agent performance.

Debt Scoring (per file)

+1  needs_refactor    +2  needs_test       +1  dead_code
+3  circular_dep      +2  spaghetti_index  +5  regression (cause in this file)
-1  test coverage     -1  plantag:done

Files exceeding their debt ceiling are excluded from build step assignments. Override: God Factory Agent only.

Forensic Database

45 forensic tables. No entries may ever be deleted.

Agent Registry

Sub-agents: Diff, Conflict, Regression, Dead Tag, Context Window Manager, Integration Verification

Nano Sea

The Nano Sea is a distributed mesh of ultra-small ML models operating as a compute layer.

• 296 nano models trained for specialized sub-tasks
• Mesh networking, P2P peer discovery, global compute pool
• Training pipeline managed by Midwife Bird-Feeding agent
• Every nano operation represented in devtag:nano taxonomy

cd NANO_train && python main.py

Model Tiers

Routes (33 modules)

Environment Variables

Copy .env.example to .env:

Copy .env.example to .env and configure:

Troubleshooting

buildModelParams export error

The shared package needs to be compiled. Run:

pnpm --filter @personal-ide/shared build

Python not found by Nano Sea

The server auto-detects Python. It tries python, python3, and py -3 (Windows).
Make sure Python 3.10+ is on your PATH.

Port already in use

Kill the process on port 3001 or 5173, or change SERVER_PORT in .env.

License

Private — All rights reserved.