Build your own version.

If you only read 3 things

The shortest path through the playbook.

The whole playbook is four pages — Start, Build, Costs, and Reference. If you can only spare 15 minutes today, read these three in order. They answer “is this for me?”, “what does it cost?”, and “how do I start?”. Everything else is detail you can pick up later.

Plain-English model

The system has one job.

Turn scattered work into a visible loop.

Capture

A call, email, report, task, calendar item, or operator request enters the system.

Route

The system decides which lane owns it: leasing, maintenance, finance, collections, reporting, reliability, or executive review.

Prepare

The lane gathers context, drafts the next step, and checks the right source of truth.

Verify

The run produces proof: a log, receipt, screenshot, returned record, or dashboard check.

Approve

A person approves anything that affects tenants, owners, money, vendors, legal status, or customer trust.

Remember

The lesson goes into a playbook, memory file, daily log, or wiki so the next run starts smarter.

What to copy

Copy the operating shape.

Actual ingredients

The build uses real software.

The reference system combines OpenAI Codex, Anthropic Claude, xAI Grok, Hermes, Telegram, Google Workspace APIs, AppFolio, ElevenLabs, Twilio, iMessage, Vercel, Cloudflare Workers, macOS LaunchAgents, Hermes schedules, browser automation, Node.js, Python, and local memory/search.

Your team does not need this exact stack. You need the same categories: a model layer, a control plane, systems of record, communication channels, schedulers, background services, memory, dashboards, and approval gates.

Skip the blank page

Starter pack — working code, ready to run.

Most people stall the first time they sit down to build because the blank page is the hardest part. The starter pack is a zip with the working Python script from the quickstart, a step-by-step Telegram bot setup, an example .env, and ready-to-paste cron and LaunchAgent configs.

The level-up

Start your own knowledge base.

The single most leveraged thing in Carson's whole setup is the Obsidian vault — plain markdown files that hold the system's durable memory and that both AIs read before working. To save you from rebuilding the structure from scratch, here's a starter vault matching his schema.

What you'll have at the end

One real loop, running on a real schedule.

A daily AI-generated summary of one thing that matters to you, delivered to Telegram at 8 AM, requiring your APPROVE before any follow-up action runs.

Step 1 · 5 minutes

Get the API key.

Sign up for an Anthropic API account at console.anthropic.com. Add $5 of credit. Generate an API key and copy it somewhere safe (a password manager, not a Notes doc).

Step 2 · 5 minutes

Make a Telegram bot.

1. Open Telegram, search for @BotFather, start a chat.
2. Send /newbot. Pick a name and a username (must end in bot).
3. BotFather sends you a token — looks like 123456:ABC.... Save it.
4. Open a chat with your new bot and send any message (“hi”). This activates it.
5. Visit https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates — note the chat.id number from the JSON response. That's where DMs will go.

Step 3 · 15 minutes

Write the script.

Save this as ~/morning-brief.py. It's intentionally tiny — under 40 lines.

#!/usr/bin/env python3
import os, sys, json
from urllib import request as http

ANTHROPIC_KEY = os.environ["ANTHROPIC_API_KEY"]
TG_TOKEN      = os.environ["TG_BOT_TOKEN"]
TG_CHAT_ID    = os.environ["TG_CHAT_ID"]

# --- 1. Ask Claude for the morning summary
prompt = "Give me a 5-bullet morning brief. Today is " \
         + __import__('datetime').date.today().isoformat() + ". " \
         + "Cover: top news for property managers in Alabama, weather, " \
         + "one thing worth thinking about today. Be specific, no fluff."

req = http.Request(
    "https://api.anthropic.com/v1/messages",
    data=json.dumps({
        "model": "claude-haiku-4-5",
        "max_tokens": 600,
        "messages": [{"role": "user", "content": prompt}],
    }).encode(),
    headers={
        "x-api-key": ANTHROPIC_KEY,
        "anthropic-version": "2023-06-01",
        "content-type": "application/json",
    },
)
data = json.loads(http.urlopen(req).read())
text = data["content"][0]["text"]

# --- 2. Send it to Telegram
http.urlopen(http.Request(
    f"https://api.telegram.org/bot{TG_TOKEN}/sendMessage",
    data=json.dumps({
        "chat_id": int(TG_CHAT_ID),
        "text": "*Morning brief*\n" + text,
        "parse_mode": "Markdown",
    }).encode(),
    headers={"content-type": "application/json"},
))
print("sent.")

Step 4 · 5 minutes

Schedule it for 8 AM tomorrow.

On Mac or Linux, type crontab -e and add this one line (use the full path to your script):

0 8 * * * ANTHROPIC_API_KEY=sk-ant-... TG_BOT_TOKEN=123456:ABC... TG_CHAT_ID=12345678 /usr/bin/python3 /path/to/morning-brief.py >> /tmp/brief.log 2>&1

Save and exit. The cron daemon will run it tomorrow at 8 AM and every day after. Logs go to /tmp/brief.log if anything breaks.

Step 5 · ongoing

What to do next.

The whole idea

Seven simple jobs.

The tiny first version

Start with one workflow.

Do not copy the whole setup on day one. Build one tiny loop first.

Public playbook for portfolio teams. Built from a real local-first workflow system, generalized for safe reuse.