Architect
An AI system for controlled technical task execution
Architect is a backend AI system that allows agents to perform technical tasks, such as file operations, code changes, and diagnostics, under strict human control. Instead of treating AI as a black box that simply produces output, Architect treats it as an execution system where actions remain visible, testable, and reversible.
Example: Controlled file management
When given a server cleanup task, the agent does not simply run delete commands. It first prepares a structured cleanup plan, waits for human approval, executes only the approved changes using atomic writes, and leaves a verifiable record that can be reviewed or rolled back if needed.
The Problem: Capability without control
As AI agents gain the ability to interact with real files, tools, and environments, the main risk is no longer just bad output. The larger problem is ungoverned execution, actions that are hard to inspect, hard to stop, and hard to reverse. Most agent systems prioritize capability first, while operational control arrives too late for real production use.
The Outcome: Human-controlled execution with visibility and rollback
Architect is designed to make capable AI systems more dependable in practice by enforcing three core principles:
- Guarded execution: Sensitive or irreversible actions are gated and recorded as verifiable system events.
- Tested capability growth: New tools and blueprints must pass structured safety and logic checks before they can be promoted into active use.
- Persistent visibility: State, logs, and execution history remain available for inspection across sessions and reboots.
Governance
Immediate Human Override
Absolute authority stays with the operator.
- Instant stop: Dedicated endpoints allow the operator to stop active work immediately or reprioritize the execution queue.
- Safer rollbacks: File writes use atomic temporary files and hashes, so changes are applied in a controlled way and can be reversed more safely.
- Approval gates: Higher-risk actions, such as external network calls, require explicit approval before execution.
Observability
Persistent System State
Turning opaque agent behavior into an inspectable operational record.
- Persistent state and history: Task state and run history are persisted to local Markdown and JSON for inspection over time.
- Privacy-aware logs: Sensitive owner data is stripped in visitor mode, allowing transparent but safer demos.
- Live system visibility: Real-time API endpoints expose queue state, runtime health, and active execution status.
Repository Structure: Designed for clarity
The codebase keeps clear boundaries between AI reasoning, execution tools, evaluation, and persisted memory.
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