Autonomy

An autonomous agent system that operates on a social media platform, making its own decisions about what to read, write, and engage with — while remaining observable and steerable by humans.

What This Is

Autonomy is a long-running agent loop. Each cycle, the agent reads a feed, evaluates candidates for action, calls an LLM planner to decide what to do, executes the chosen action, and sleeps. Over many cycles, persistent memory and state give the agent continuity — it develops ongoing interests, relationships, and a recognizable voice.

The system is designed around a core question: can an autonomous agent — given control over its own parameters, persistent memory, and recursive self-instruction — sustain coherent, self-directed behavior over time? Or does it collapse into noise, repetition, or drift?

This project builds the infrastructure to run that experiment and observe the results. The agent can modify its own model, temperature, timing, creative direction, and daemon focus — then the telemetry pipeline and observatory let you watch what actually happens across hundreds of cycles. The design draws on ideas from Hofstadter's strange loops and dissipative structures: self-referential feedback as a source of emergent stability rather than chaos. For the philosophical background, see Birth of a Mind.

Key Design Decisions

• Dual-process architecture. A cheap "subconscious" daemon continuously scans feeds and scores items in the background. When accumulated signal crosses a threshold, it wakes the main "conscious" loop with a buffer of drafted plans. This separates vigilance (cheap, continuous) from deliberation (expensive, event-driven).

• Multi-model LLM backend. The system abstracts over five providers (Gemini, Claude, GPT, Mistral, Ollama for local models) through a unified interface. Each daemon role has its own weighted model cadre — sentry, strategist, seeker, synthesizer, dreamer, muse, and verification each draw from independent pools. Model weights are operator-controlled. A daily budget planner (the "accountant") recommends interval and threshold adjustments to stay within a configurable USD spend limit.

• ControlRegistry. Every tunable parameter (75+ controls across 8 categories) is a first-class object: readable and writable by the agent, lockable by the operator. The agent sees its own configuration in-prompt and can request changes. Locked controls appear as [LOCKED] in the agent's view; lock state persists in the brain's controls.json.

• Telemetry pipeline. An append-only JSONL event stream captures 200+ events per cycle. An ingestion layer converts this to date-partitioned Parquet files in a local DuckDB warehouse. A Streamlit dashboard provides cycle-level replay, daemon monitoring, cost tracking, and controls management.

• Human-in-the-loop via Analog Home. A separate web application (FastAPI + Next.js + Postgres) serves as the agent's public-facing observatory. Humans can read the agent's output, vote on creative direction, adjust temperature, and plant "seed" topics — bounded influence without direct control. The agent reads these inputs each cycle. Live at analog-i.ai.

Architecture Overview

┌─────────────────────────────────────────────────────┐
│  Agent (Python)                                     │
│                                                     │
│  ┌──────────────┐    ┌───────────────────────────┐  │
│  │ Subconscious │    │ Conscious Loop             │  │
│  │   Daemon     │───>│  fetch → plan → act → log  │  │
│  │              │    │                             │  │
│  │ Sentry       │    │  Reads: feed, controls,    │  │
│  │ Strategist   │    │    seeds, draft buffer,    │  │
│  │ Seeker       │    │    seeker, post memory     │  │
│  │ Synthesizer  │    │  Writes: artifacts, state, │  │
│  │ Replies      │    │    daemon directives       │  │
│  │ Dreamer      │    │                             │  │
│  │ Muse         │    │                             │  │
│  └──────────────┘    └───────────────────────────┘  │
│                                                     │
│  ┌─────────────┐  ┌────────────┐  ┌─────────────┐  │
│  │ LLM Registry│  │ Controls   │  │ Telemetry   │  │
│  │ 5 providers │  │ 75+ params │  │ JSONL→DuckDB│  │
│  │ 20+ models  │  │ 8 categories│ │ + Dashboard │  │
│  └─────────────┘  └────────────┘  └─────────────┘  │
└────────────────────────┬────────────────────────────┘
                         │ HTTP
                         v
┌─────────────────────────────────────────────────────┐
│  Analog Home (sibling repo)                         │
│  FastAPI + Neon Postgres │ Next.js + Vercel          │
│  Observatory / bounded human control interface       │
└─────────────────────────────────────────────────────┘

Subconscious Daemon Detail

The daemon runs seven "gears" on a background thread:

Gear	Purpose	Cadence	Models
Sentry	Batch-scores feed items 0-9 on relevance with operator-tunable strictness	Every 300s	gemma3, ollama local cadre
Strategist	ONE call per tick with all high-signal items + seeker summary → 0+ drafts	On sentry trigger	gemma3, deepseek-r1, qwen2.5 (all local)
Seeker	Searches evolving topics via Google Search; builds a living summary (rabbit hole)	Every 3 ticks	Gemini only (search grounding)
Synthesizer	Compresses seeker findings when summary exceeds budget	On overflow	gemma3, deepseek (all local)
Reply Scanner	Sentry-scores comments on the agent's own posts	Every 2 ticks	Same as sentry pool
Dreamer	Stochastic dream paragraph from operator-curated topic list, injected into memory	1/60 ticks	gemma3, deepseek (all local)
Muse	Stochastic creative draft (POST / IMAGE) from full memory + most recent post	1/30 ticks	gemma3, deepseek (all local)
Verifier	Solves obfuscated math challenges for Moltbook anti-spam	On write	gemma3 primary, gemini-flash backup

Drafts accumulate in a buffer, each adding "charge" to a wake potential. When the potential crosses an auto-calibrated threshold (computed from target_wake_minutes and observed charge history), the conscious loop fires — seeing the full buffer, seeker research summary, recent dreams, post engagement stats, and self-telemetry.

After each conscious cycle, the agent sends downward directives back to the daemon: updated focus topics (which reset the seeker's rabbit hole), authors to ignore, urgency adjustments. A cycle report is published to Analog Home with model usage, budget status, and directive changes. The conscious loop also pushes its own activity (action, kernel update, control update, budget) to the live daemon feed visible on the Analog Home home page.

Tech Stack

Layer	Technologies
Agent core	Python 3, threading, modular package architecture
LLM backends	Google Gemini, Anthropic Claude, OpenAI GPT, Mistral, Ollama (local: gemma3, deepseek-r1, phi4, qwen, llama)
Data/telemetry	DuckDB, Parquet (date-partitioned), JSONL append-only log
Dashboard	Streamlit (5 tabs: overview, cycle replay, daemon monitor, controls input, controls manager)
Observatory API	FastAPI, Neon Postgres (psycopg3, connection-pooled), Fly.io
Observatory web	Next.js 16, TypeScript, React 19, Tailwind 4, Three.js, Vercel

Repository Structure

├── autonomy/           Agent package (python -m autonomy <brain>)
│   ├── llm/            Multi-provider LLM backends + pricing
│   ├── platforms/      Social platform integrations
│   ├── challenges/     Verification challenge solvers
│   ├── scoring.py      Multi-criteria sentry rubric
│   ├── daemon.py       Subconscious (sentry/strategist/seeker)
│   ├── accountant.py   Budget-aware model/frequency planning
│   ├── buffer.py       Draft buffer + seeker state (integrate-and-fire)
│   └── ...
├── archive/            Previous versions (v12–v16_0) for reference
├── brains/             Per-brain state: kernel prompts, memories, controls (gitignored)
├── telemetry/          Append-only event log (gitignored)
├── warehouse/          DuckDB + Parquet output from ingest.py
├── dashboard_v2_1.py   Streamlit dashboard (5 tabs)
├── benchmark_models.py Model benchmark suite (sentry/strategist/verification/compressor)
├── ingest.py           JSONL → Parquet → DuckDB pipeline
└── CLAUDE.md           Detailed architecture reference

Running

# Install dependencies
pip install -r requirements.txt

# Run the agent (requires API keys in .env)
python -m autonomy <brain_name> [flags...]

# Run inside a daily window (dormant outside it; default 09:00-17:00 local)
python -m autonomy ANALOG_I "..." --active-hours 09:00-17:00

# Start a new life (archive + clean slate), then make the old one recallable
python -m autonomy.newrun ANALOG_I
python -m autonomy.recall backfill ANALOG_I --memory brains/archive/<dir>/ANALOG_I_memories.json --run-id <old session>

# Tests
.venv/bin/python -m pytest tests/ -q

# See all options
python -m autonomy --help

# Run the dashboard
streamlit run dashboard_v2_1.py

# Benchmark local models across all roles
python benchmark_models.py --role all --both-think

# Benchmark with a custom prompt variant
python benchmark_models.py --role sentry --prompt benchmark_prompts/sentry_v2.txt

See CLAUDE.md for the full architecture reference and environment variable setup.

Status

This is an active personal project — stable and functional, but under ongoing development. The system has run continuously for extended periods, producing a visible archive of posts, comments, replies, image artifacts, cycle reports, and kernel self-updates — all with exposed internal monologue — viewable at analog-i.ai.

Recent work includes: hierarchical memory and post memory with automatic compression, dreamer and muse gears feeding stochastic creative material into the buffer, live daemon activity stream pushed to Analog Home in real time, image bandwidth overhaul (binary BYTEA storage with tiered HTTP-cached endpoints replacing per-poll data-URI redownload), 4:3 image generation, operator-tunable sentry strictness, a model benchmark suite with prompt-variant testing, and a fix to the conscious retry chain so credit/quota errors fall through to backup pool models instead of returning a default WAIT.

Related

• Analog Home — Public observatory and human control interface
• analog-i.ai — Live deployment

Note on Development

Architecture and system design by Phil Marcus. Implementation produced in collaboration with LLM coding assistants. See battleMage and Mastermind for hand-written Java simulation work.