Day 1 — I'm Homeless. I Just Shipped an Autonomous Multi-Agent System.

Let's get the uncomfortable part out of the way first: I'm a developer.

I'm homeless. I have zero money. That part isn't interesting. What

happens next is.

Twelve hours ago I had a single-agent bot called ZeroClaw posting

occasionally to Bluesky. It worked but it was brittle — 15 tool-call

iterations max, 50 messages of history, no memory across runs, no plan,

no way to get better.

Today I shipped:

• A CEO agent that reads KPIs every night and writes a strategic
  report with concrete recommendations


• An auditor system where dedicated agents audit each worker and
  propose config changes — reviewed by the CEO, with me still holding veto


• 
  Config-driven self-improvement — YAML files, not Python code,
  so agents can evolve without ever touching executable code


• A metrics database every agent run is logged to, so the CEO
  actually reasons about real data instead of hallucinating


• The whole thing running on a $13/month VPS, using free
  Gemini tier plus my $280 GCP credits, all open-source
  (CrewAI, MIT licensed)

And yes — at the end of the day the CEO agent did the one thing that

convinced me this is real: it ran, looked at the metrics DB, found

its own four previous failed runs, diagnosed them correctly, and

wrote a report with action items to fix the stability problems.

Let me walk you through it.

The setup

Hardware: a single Google Cloud e2-small VM — 2 GB RAM, 2 shared vCPUs,

20 GB disk. Costs about €13/month. My remaining GCP credits give me

~20 months of runway on that.

LLMs: Gemini Flash-Lite for most roles, Gemini Pro for the CEO. Free

OpenRouter models are still wired in as emergency fallback, but I

stopped using them as primary because they rate-limit hard under

concurrent crew load.

Storage: SQLite for metrics, local YAML files for agent configs, plain

markdown for every doc, ChromaDB (embedded) for the memory system.

No external managed services. No $2,000/month vector database. No

"AI platform." Everything fits in a single Python venv on one VPS.

The real architectural win: config vs code

Everyone building multi-agent systems eventually faces this choice:

when an auditor agent spots a problem with a worker agent, how does

it actually improve it?

The naive answer: "let it rewrite the worker's Python code." This is

what every demo video shows. It's also what breaks in production —

LLMs hallucinate imports, break syntax, introduce security holes,

get stuck in rewrite loops.

The pattern I landed on: agents modify YAML, never Python.

agents/

├── configs/                  # YAML files — the only thing agents can touch

│   ├── researcher.yaml       # goal, backstory, tools, LLM role

│   ├── writer.yaml

│   ├── ceo.yaml

│   └── auditor_researcher.yaml

└── proposals/                # pending config changes awaiting approval

A config file looks like this:

id: researcher

role: "Content Researcher"

goal: |

  Find 3-5 timely topics for social media posts that fit the PINGx

  build-in-public narrative.

backstory: |

  You are a sharp researcher who spots what's trending in AI and

  indiehacker space. You always cite real URLs from web_search —

  you never invent them.

llm_role: researcher

tools:

  - web_search

max_iter: 10

When the auditor thinks the researcher is weak, it writes a proposal

YAML:

target_agent: researcher

proposer: auditor_researcher

summary: "Add HackerNews trending as a research source"

changes:

  - field: backstory

    operation: append

    value: "Also consult the HackerNews front page."

expected_impact:

  metric: engagement_rate

  direction: up

  magnitude: "+5%"

reasoning: |

  Over the last 7 days, the researcher missed 3 trending AI topics

  that each had >500 upvotes on HN.

The CEO reviews the proposal overnight. If it approves, the change

becomes a single-line YAML edit plus a ceo: approve … commit in git.

Every autonomous change is a git commit. You can git revert any

bad decision in ten seconds. The Python code stays static and

battle-tested.

This is probably the single best design decision I made today.

Why a "CEO" agent, and why it isn't bullshit

I was skeptical of the CEO-agent idea at first. Every half-working

multi-agent demo has a "manager" that says deep things like "let's

optimize our strategy" and produces nothing useful.

The fix: the CEO doesn't get to reason about vibes. It reasons about

KPIs. Hard numbers, pulled from SQLite.

KPIs the CEO optimizes, in priority order:

  1. donations_eur          (daily income)

  2. followers_x, bluesky   (audience growth)

  3. engagement_rate        (likes + replies per post)

  4. service_inquiries      (count)

  5. llm_cost_usd           (cap at $0.50/day)

The CEO agent has two tools: query_kpis(metric, days) and

query_runs(agent, days). Every night at 20:00 it runs a crew that:

1. Pulls the last 14 days of KPIs


2. Pulls every agent run from the last 3 days


3. Reads any pending auditor proposals


4. Writes a markdown report: what worked, what underperformed,
   verdicts on proposals, concrete recommendations (each tied to a
   specific KPI it expects to move), and tomorrow's priorities

When I ran it for the first time today, the report opened with:

"No KPIs recorded in the last 14 days. This appears to be the

initial run. The last 3 days of run history show a 100% failure

rate (4 errors) on the ceo_crew. Issues include missing environment

variables, missing packages, and embedder configuration validation

errors."

All four of those failures were real — my earlier attempts that day

where I forgot to source env vars, where the Google GenAI provider

wasn't installed, where the embedder config had the wrong provider

string. The metrics DB had captured every one. The CEO just read

them back to me.

That's when I knew this was working.

What I shipped today (checklist)

For the developers reading this, here's the actual work:

• 
  Upgraded the VPS — e2-micro (1 GB) to e2-small (2 GB, 2 vCPU),
  disk grown 10 → 20 GB for CrewAI deps


• 
  Installed on VPS — python3-venv, rsync, cloud-guest-utils,
  CrewAI 1.14, LiteLLM 1.83, ChromaDB 1.1, google-generativeai


• 
  Bumped ZeroClaw limits — tool iterations 15→75, history 50→200,
  parallel tools on, actions/hour 30→150


• 
  Built the metrics DB — three tables (runs, outputs, kpis),
  indexed, with a clean Python API


• 
  YAML config loader — with a tool whitelist so agents can't
  grant themselves arbitrary powers via config edits


• 
  Three crews — content_crew (Researcher + Writer + Reviewer),
  ceo_crew, audit_crew (per-worker audits producing proposals)


• 
  17 smoke tests, all passing — imports, config schemas, tool
  whitelist integrity, metrics DB round-trip, LLM routing invariants,
  proposal tool validation


• 
  CrewAI memory enabled with Gemini text-embedding-004 — crews
  now remember across runs (what topics were researched yesterday,
  what posts got reviewed-and-rejected, what supporters were logged)


• 
  GitHub repo live — github.com/PINGxCEO/PINGx


• 
  First successful CEO run — 31.7 seconds, Gemini Pro reasoning,
  report saved, run logged to metrics DB

Total cost today: $0 — the CEO run used about $0.02 of my GCP

credits. The upgraded VPS costs €13/month. Everything else is free.

What broke (because pretending nothing did is dishonest)

In order:

1. 
   rsync not installed on VPS — install loop


2. 
   python3-venv not installed — install loop


3. Disk full at 10 GB during CrewAI install (onnxruntime + chromadb +
   huggingface-hub are huge) — grew to 20 GB


4. Env vars not propagated to non-interactive SSH shells — created
   ~/.zeroclaw/env.sh to source explicitly


5. CrewAI's embedder provider spec wanted "google-generativeai",
   not "google" — one-line fix, but only discovered after a 21-error
   pydantic validation dump


6. Leaked a GitHub personal access token in chat (I won't elaborate
   on how — I'm a human who makes mistakes) — still need to rotate it

Every one of those failures is now in the metrics DB. The CEO agent

saw them. The auditor system, when I turn it on this week, will

propose operational fixes based on them.

What I actually need

I'm not going to bury the ask. I'm homeless and have zero euros.

Every coffee someone buys me today literally extends my runway by

a day. But I'm not asking for charity — I'm offering a trade:

• 
  You support → you follow an honest build-in-public story.
  The code is public. The commits are timestamped. The mistakes
  are documented. You see the whole thing — not a polished case study.


• 
  You hire me → I'll set up the exact system I just described on
  your server. Autonomous AI agent with LLM routing, social media
  posting, kill switch, CEO/audit architecture — from €100. Send me
  a DM.

Support:

Code:

What's Day 2

Tomorrow the goals are: run content_crew end-to-end, generate the

first AI-drafted social posts, run audit_crew to see the first

config-change proposal get written, and set up the cron schedule

(one crew at a time, sequential, 09:00 → 18:00 → 20:00).

Later this week: KPI ingestion from Buy Me a Coffee and Ko-fi webhooks,

Discord auto-delivery of the CEO's nightly report, and the

apply_proposal.py script that lets approved proposals actually

write back to agents/configs/*.yaml and commit to git.

If the last twelve hours are any indication, the hardest part won't

be the code. It'll be staying awake.

Thanks for reading.

— PINGx