How I run 12 autonomous Claude agents across my life — zero infrastructure, zero code

Saulo Ferreira — Sun, 29 Mar 2026 04:30:59 +0000

I have Claude Cowork sessions running autonomously across my life right now.

Each manages its own domain, fires as often as I need the data fresh, reads a Notion page for current state, finds progress to make, writes what it found back to Notion, texts me if anything needs a decision. Each one is ready to pick up where the last session left off.

A "heartbeat" session rolls all of them up every 30 minutes and tells me exactly what needs my attention across everything.

And here's the catch: No OpenClaw. No servers. No always-on processes. No code.

The Pattern

Each autonomous agent is a scheduled Cowork session. The architecture has four parts:

1. SSOT (Single Source of Truth)
A Notion page that works as the agent's memory (or a local .md file, but Notion works cleanly with search/update MCP tools). The session reads it at the start of every tick. Writes progress back before it closes. This is enforced by a skill file explained next. The following scheduled tick picks up where the last one left off. No state lives in Claude's context between sessions — it all lives in Notion, or locally on your computer.

2. SKILL.md
A markdown file that defines the agent's behavior. The key is forcing it to check Notion at the start (or after any context would have changed) and update it as any new context is added. The session reads this file at the start of every tick, enforcing RAG-style retrieval from a perfect SSOT.

3. Scheduled Cowork sessions
The execution engine. You create a scheduled task in Cowork — every hour, every morning, whatever you need. Each session is fully stateless at startup: read SKILL.md, read SSOT, do work, write back, done — or notify if urgent.

4. Notification layer
Agents reach you when they need you, not the other way around. I route by urgency: LOW goes to a daily digest, MEDIUM pings Discord, HIGH sends a text. You answer when you want. The agent parks and waits. Your other agents keep running.

Why this works (the key architectural insight)

The sessions don't share state. Domain-specific knowledge remains precise and in your control. Each one reads from and writes to its own Notion page. You can run 5 or 15 of them in parallel because there's no coordination problem — the only shared resource is your attention, and the notification layer manages that.

This solves the fan-out human-in-the-loop problem: one human, many parallel agents. The heartbeat session is the aggregator — it reads an "Agent Status" field from each domain's Notion page and produces a single digest. The human chooses what to prioritize based on that digest.

How much setup?

Manual:
New domain: write a SKILL.md (the behavioral contract) + create a Notion page (the state store). About 15 minutes. Then schedule the Cowork session. It runs from there.

The Notion page doesn't need to be elaborate. Mine is just a few sections: current status, last action, next action, open questions, session log. The agent knows what to read and what to write because the SKILL.md tells it.

Meta-skill:
I have a meta-skill — a SKILL.md that generates other SKILL.md files with the enforcement rules for this pattern baked in. I tell Claude "set up a new domain for X" and it creates the Notion page (state store) and the behavioral contract (SKILL.md) in one conversation, then ends with the prompt to schedule the Cowork session at whatever cadence I want. New autonomous agent, end to end, in one conversation. No Playwright, no browser automation scripts, no custom tooling.

Why not OpenClaw?

OpenClaw requires technical knowledge and comes with real security risks for business/life operations. The cstack pattern has the same safety model as Cowork — no exposed ports, no attack surface. Cowork sessions run in Anthropic's sandboxed, permission-oriented infrastructure. Your only footprint is Notion pages and skill files.

How does Dispatch change the game?

Dispatch bridges the single-gateway problem — you can answer a blocking question from any Cowork session from any device through the Claude app, and it routes to the right session. Full unblocking and status monitoring, on the go, away from your computer.

The full pattern

I documented the architecture in a single README:

→ https://github.com/srf6413/cstack

Happy to answer questions about how any piece of this works in practice.

DEV Community: Saulo Ferreira

[Boost]