Architect
A Self-Aware, Governable Agentic System
Architect is a backend AI system designed to be a working implementation of the principles outlined in my research on memory-enabled AI, evolved into a fully active, self-growing operator. It moves beyond theoretical ethics to provide a concrete, engineered solution where AI transparency, test-first execution, and strict human authority are architectural guarantees.
The Architectural Problem: Black Boxes and Autonomy Run Amok
As AI systems become more autonomous, they risk eroding user agency through opaque decision-making, unverified shell execution, and the potential to leak private data. To build trustworthy, capable AI, accountability and deterministic rollbacks cannot be an afterthought—they must be hardcoded into the execution loop from day one.
The Solution: Principled Execution and Autonomous Growth
Architect replaces the passive “chat” paradigm with a robust, multi-agent operating loop (
observe → plan → policy_check → execute → verify → log). The system treats the LLM merely as a replaceable reasoning driver, while its identity, memory, and safety guardrails live durably on disk.Agent Core & Reasoning
The Growth Engine
A gated pipeline for self-expanding capabilities.
- Test-First Promotion: The system grows via explicit YAML blueprints. Every new capability must be scaffolded, dry-run, and pass a nightly Evaluator suite (scoring ≥95% on katas and safety checks) before it is promoted to production.
- Micro-Agent Swarm: Execution is handled by specialized roles (e.g., Planner, OpsAgent, Digestor), ensuring a strict separation of concerns.
- Small-LLM-First: A built-in router defaults to small, local models (e.g., Llama 3.1 8B, Qwen) for planning and summarization, escalating to larger models only when uncertainty is flagged.
System Integrity & Safety
Maker Primacy & FS Toolkit
Ensuring absolute human authority and reversibility.
- Absolute Override: Exposes FastAPI endpoints (
/cancel_all,/prioritize) that allow the “Maker” to instantly pre-empt and stop any task the agent is currently executing. - Reversible-First Sandboxing: File system writes avoid raw shell commands, utilizing atomic temporary files and cryptographic hashes to guarantee every action has a verifiable, rollback-ready receipt.
- Explicit Approvals: Irreversible or Tier-2 external network changes are strictly gated, requiring cryptographic
.okapproval files to proceed.
Operational UX & MLOps
Identity & Observability
Transparent operations for developers and visitors.
- Durable Self-Awareness: The agent’s state, active tasks, and episodic memories are persisted to local JSON and Markdown files, allowing the system to accurately self-report its internal status across reboots.
- Privacy Guard: Distinguishes between the system Owner and general Visitors, utilizing deny patterns to automatically strip sensitive owner data from outputs in visitor mode.
- Local Dashboards: Exposes operational API endpoints (
/ui/status,/ui/agents) to power a real-time maker dashboard of the system’s execution queue and health.
Repository Layout: An Architecture of Clarity
The repository isolates the API transport from the core agentic loop and state memory, enforcing clean boundaries and testability:
architect/
├── src/back/
│ ├── app.py & main.py # FastAPI transport and the core agent CLI loop
│ ├── core/ # Domain logic: Evaluator, Growth Engine, Privacy Guard
│ ├── models/ # Pluggable LLM drivers (Local Llama, Model Router)
│ ├── tools/ # Sandboxed execution tools (fsio, run_cmd)
│ └── evals/ # Nightly katas, leak checks, and policy tests
├── blueprints/ # YAML definitions for new capabilities (e.g., disk_health)
├── identity/ # The agent's laws, purpose, and voice
└── memory/ # Persisted state, episodic logs, and agent registry