A personal CRM and operations layer running on an autonomous AI agent runtime
A personal operations platform, where the agent is the operator
A bespoke personal CRM and operations layer — contacts, integrations, an integration-toggle sheet, a strict secrets model — running not as an app but as a set of tasks an autonomous AI 'employee' carries out for me. The runtime, not the UI, is the product.
A stack of consumer-SaaS subscriptions → one personal CRM where the agent does the operating.
| Before | After | |
|---|---|---|
| Where the work happens | across a stack of consumer-SaaS apps | one runtime, with an agent doing the operating |
| How you reach your data | open the right app, search, scroll | ask the agent in plain language |
| Integrations | a fragile chain of webhooks and Zapier | explicit toggles, each priced and budgeted |
| Where secrets live | in whichever apps you set up first | one model, one place, one set of rotation rules |
| What the platform 'looks like' | a UI you click through | an agent you delegate to |
A pile of subscriptions and a swivel-chair operating system becomes one personal CRM where the AI is the operator. The stack the rest of the world buys ten apps for runs as five flat tables and an agent that knows them.
What I built
A bespoke personal operations platform that I actually run my practice on. It looks small on paper — a small CRM, an integration-toggle sheet, a secrets model, an audit log — but the part that matters is what runs it: an autonomous-AI-agent runtime (OpenClaw) that operates the platform on my behalf.
- The CRM is small on purpose. Contacts, projects, interactions — five flat tables instead of the dozen the SaaS equivalents have. Less surface for the agent to learn; less for me to maintain.
- Integrations sit behind explicit toggles, each with a budget. Email, calendar, docs — each one is opt-in, with a cost ceiling. The platform only spends what it's authorized to.
- Secrets live in one place, with one model. The agent never sees raw keys, only references. Rotation is on a schedule, not a memory.
- The agent is the operator. Most of what would be a click-through-three-apps task — "pull the last three notes on this contact", "who haven't I followed up with this week", "summarize today's emails by project" — goes to the agent, which uses the platform on my behalf and reports back.
- Every action is audited. Tool calls, budgets spent, decisions made — all logged, so the system stays auditable even when most of the work is done without me touching it.
The clean line: the platform stores the data; the agent does the operating; I delegate in plain language.
Why it matters
This is the workshop. The other cases here are systems built for clients or as products. This one is the stack I actually run my practice on, and it's where I find out what works before I ship it elsewhere. The decisions that get hard-won here — how to bound an agent's permissions, how to budget per task, where to put the audit log — are the ones that show up later in the client engagements as the parts I already know how to do safely.
It's also a deliberate counterpoint to the productized version of the same idea (Software of You). The product has to please many people; the daily driver only has to please me. Keeping both gives me the test bed and the showcase at once.
- 01Define the CRM
A small, flat CRM (contacts, projects, interactions) lives in the platform as the source of truth — fewer tables than the SaaS equivalents, on purpose.
- 02Toggle the integrations
Each integration (email, calendar, docs) sits behind an explicit toggle with its own cost ceiling, so the platform only runs what's worth its budget.
- 03Define the secrets model
Secrets live in one place, rotate on a schedule, and the agent never sees a raw key — only references.
- 04Hand work to the agent
Most operations — 'pull the last three notes for this contact', 'summarize today's emails by project', 'who haven't I followed up with' — go to the agent, which uses the platform on my behalf.
- 05Audit
Every agent action is logged with the tool calls it made and the budget it spent — so the system stays auditable, even when most of the work is done without me touching it.
Most one-person practices end up with a SaaS stack and a swivel chair. This is the opposite: one runtime, one CRM, explicit integration toggles, one secrets model, and an agent that does most of the actual operating. The work doesn't happen in a UI; it happens in delegation.