Bootstrap and validate a self-hosted AI agent

Official starter pack of The Autonomous Stack. It turns an autonomous agent idea into a runnable, observable and compliant system in 48 hours. Designed for solo developers, SaaS founders and teams who want an agentic foundation before adding specialized domains.

Table of contents

1. Overview
2. Architecture
3. OODA diagram
4. Quick Start
5. Pack structure
6. Target personas
7. Roadmap
8. License

Overview

starter-v2 is the common foundation of all Self-hosted agent packs. It provides:

• An OODA loop specific to starting up an agent.
• 5 named prompts covering architecture, configuration, guardrails, scaling and reporting.
• A checklist of 35 operational steps with commands.
• Installation, prompt testing and orchestration scripts.
• Configuration templates ready to customize.

Unlike v1, which reads like a book, v2 is runnable: you run scripts/install.sh, you copy templates/, you execute scripts/run_agent.py.

Architecture

The pack is built on six startup states that form an agent-oriented cycle:

┌─────────────────────────────────────────────────────────────────────┐
│                  AUTONOMOUS STACK STARTER v2.0                       │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   ┌──────────────┐     ┌──────────────┐     ┌──────────────┐       │
│   │ BOOTSTRAPPING│────→│ CONFIGURING  │────→│   RUNNING    │       │
│   └──────────────┘     └──────────────┘     └──────┬───────┘       │
│          ↑                                         │                │
│          │                                         │                │
│          │           ┌──────────────┐             │                │
│          └───────────│   REPORTING  │←────────────┘                │
│                      └──────┬───────┘                               │
│                             │                                       │
│                             ↓                                       │
│   ┌──────────────┐     ┌──────────────┐     ┌──────────────┐       │
│   │   SCALING    │←────│  MONITORING  │←────│   RUNNING    │       │
│   └──────────────┘     └──────────────┘     └──────────────┘       │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

Data flow

Idea / need    →  BOOTSTRAPPING  →  CONFIGURING  →  RUNNING
                                              │
                                              ↓
                     ┌──────────────────────────────────────┐
                     │  MONITORING  →  SCALING  →  REPORTING │
                     │  (heartbeat, errors, metrics)          │
                     └──────────────────────────────────────┘

OODA diagram

         ┌─────────────────────────────────────┐
         │            IDLE / INIT              │
         └──────────────┬──────────────────────┘
                        │ start()
                        ▼
         ┌─────────────────────────────────────┐
         │         BOOTSTRAPPING               │
         │  Define the mission, values,        │
         │  sensors and actuators.             │
         └──────────────┬──────────────────────┘
                        │ bootstrap_complete()
                        ▼
         ┌─────────────────────────────────────┐
         │         CONFIGURING                 │
         │  Load config.yaml, validate the     │
         │  API keys, create the structure.    │
         └──────────────┬──────────────────────┘
                        │ config_valid()
                        ▼
         ┌─────────────────────────────────────┐
         │           RUNNING                   │
         │  Run the first OODA loop.           │
         └──────────────┬──────────────────────┘
                        │ cycle_complete()
                        ▼
         ┌─────────────────────────────────────┐
         │         MONITORING                  │
         │  Watch heartbeat, errors,           │
         │  latency and costs.                 │
         └──────────────┬──────────────────────┘
                        │ health_check_passed()
                        ▼
         ┌─────────────────────────────────────┐
         │           SCALING                   │
         │  Add workers, caching,              │
         │  or specialized agents.             │
         └──────────────┬──────────────────────┘
                        │ scaling_event()
                        ▼
         ┌─────────────────────────────────────┐
         │         REPORTING                   │
         │  Produce the health report,         │
         │  lessons learned and next           │
         │  steps.                             │
         └──────────────┬──────────────────────┘
                        │ report_delivered()
                        │ (loop back to CONFIGURING)
                        ▼

Quick Start

1. Installation

cd scripts/
chmod +x install.sh
./install.sh

2. Configuration

cp templates/starter_config.yaml ./starter.yaml
cp templates/agent_rules.yaml ./rules.yaml
# Edit starter.yaml and rules.yaml with your settings

3. Testing the prompts

python3 scripts/test_prompt.py --prompt bootstrap --input "My agent must monitor Reddit and create alerts"

4. Running the agent

python3 scripts/run_agent.py --config starter.yaml --duration 60

Pack structure

starter-v2/
├── README.md              <- This file
├── SOUL.md                <- Startup-specific OODA states
├── PROMPTS.md             <- 5 named prompts
├── CHECKLIST.md           <- 35 steps with commands
├── SPEC.md                <- Configurable parameters
├── CHANGELOG.md           <- v1.0.0 and v2.0.0 history
├── pack_memory.py         <- Private local usage memory (feedback, similar cases)
├── starter-v2.json        <- Manifest and stats
├── scripts/
│   ├── install.sh         <- Installs Python, venv and dependencies
│   ├── config.yaml        <- Commented configuration template
│   ├── test_prompt.py     <- Tests a prompt with Ollama or a stub
│   └── run_agent.py       <- Minimal OODA orchestrator
└── templates/
    ├── starter_config.yaml
    └── agent_rules.yaml

Use a local model (Ollama)

The optional LLM step can also run on your own machine through Ollama, so no text leaves your server. No account and no API key.

ollama pull <model>               # any chat model you like
export PACK_LLM=ollama            # prefer Ollama even if a coding-agent CLI is installed
export PACK_OLLAMA_MODEL=<model>  # optional: default is the first chat model the server lists
python3 -c "import llm_adapter; print(llm_adapter.detect())"   # prints: ollama

• PACK_OLLAMA_HOST points to another server (default http://127.0.0.1:11434); OLLAMA_HOST is also read when PACK_LLM=ollama.
• PACK_OLLAMA_NUM_CTX sets the context size if your reports or prompts are long.
• Without PACK_LLM, a local Ollama server is used only when no Claude Code, Kimi Code or Codex CLI is found.
• If the server is down or the model is missing, the pack keeps working in its deterministic mode.

Learning memory (local and private)

Every LLM call this pack makes is journaled in ./.pack_memory/ next to the code, so the pack can improve for you. Nothing is ever sent anywhere.

• What is kept: the task name, the masked input, the masked answer, status and latency. Keys, tokens, e-mails, phone numbers, IP addresses, card and IBAN numbers and personal paths are masked before writing; the system prompt is never stored.
• Teach it: python3 pack_memory.py feedback last ok confirms a result, python3 pack_memory.py feedback last bad --fix "the right answer" corrects it. Confirmed and corrected runs are reused as validated examples when a similar input comes in. Unrated runs are never injected into a prompt.
• Find similar cases: python3 pack_memory.py similar "some text" and python3 pack_memory.py clusters (groups of near-identical failures) work in plain Python, no model needed. Optional meaning-based matching uses an embedding model you already run locally: python3 pack_memory.py enable-semantic (Ollama on this machine only).
• Share, only if you want: python3 pack_memory.py export writes an anonymised summary (counts, statuses, size buckets, no text) for you to review.
• Control: PACK_MEMORY=0 turns it off, PACK_MEMORY_STORE_TEXT=0 keeps fingerprints only, python3 pack_memory.py purge --yes wipes it.

Target personas

Roadmap

• v2.1: Native integration with the agent-{domain}-v2 packs.
• v2.2: Multi-agent mode with an internal A2A bus.
• v2.3: Web monitoring dashboard (real-time OODA states).

License

Proprietary — internal use only. Do not redistribute.

Last updated: 2026-06-18