B2: Chief of Staff Agent

I built a Chief of Staff agent. It runs my life.

Not metaphorically. Every morning, it pulls my calendar, scans my email, checks my tasks, and tells me what matters today. It knows what I'm working toward this week, this month, this quarter. It prioritizes ruthlessly. And it gets better every time I give it feedback.

Here's how it works.

The Architecture

The Chief of Staff doesn't do everything itself. It orchestrates. It coordinates a team of specialized agents, each with a single job:

Chief of Staff (orchestrator)
├── Planning      → Strategy, goals, milestones
├── Tasks         → Linear integration
├── Calendar      → Google Calendar (multiple accounts)
├── Email         → Gmail triage (multiple accounts)
├── Content       → Social + blog scheduling
└── Relationships → Context on people

Each agent lives in its own folder with two key files: AGENT.md and memory.md. More on those in a moment.

What a Morning Looks Like

When I say "morning standup," the COS:

1. Verifies the current date (yes, really—LLMs get this wrong sometimes)
2. Reads my quarterly goals and weekly focus from the Planning agent
3. Queries Linear for tasks in "Today," "In Progress," and "This Week"
4. Pulls today's calendar events across both personal and work accounts
5. Scans priority emails from both inboxes
6. Synthesizes everything into a single update with clear priorities

The output looks like this:

OVERVIEW
5 focus hours left. The product demo is your highest leverage
task today. Block time this morning before the 2pm call.

THIS WEEK GOALS
- ⭐️ Ship the demo by Thursday
- ⭐️ Publish Monday's blog post
- ⭐️ Clear the backlog of partner emails

TODAY PRIORITIES
- 🚨 Complete: Finish demo flow 💪
- ⚪ Advance: Draft partner responses ⚡️
- ⚪ Consider: Review content calendar 🧠

It's not just a list. It's prioritized. It tells me why something matters. It connects daily tasks to weekly goals.

The Learning System

The part that matters most: it learns.

Every agent has two files that make this work:

AGENT.md is the agent's brain. It defines the role, workflow, integrations, and—critically—an "Accumulated Learnings" section at the bottom. This is where durable knowledge lives. When I give feedback that should change how the agent works forever ("always filter out sales emails," "prioritize shipping over planning"), it goes here. This file is committed to Git and versioned.

memory.md is the agent's scratchpad. It holds private notes, temporary context, and personal preferences that don't need to be shared. This file is gitignored—local only.

When I say "that's not a priority" or "do it this way instead," the agent figures out which file to update. Workflow changes go to AGENT.md. Personal context goes to memory.md.

Here's what an accumulated learning looks like in AGENT.md:

### Accumulated Learnings

**Priority Logic (2026-01-15)**
When surfacing tasks, always put "Complete" items first (must
finish today), then "Advance" items (must make progress), then
"Consider" items (optional). Never mix these categories.

**Email Filtering (2026-01-15)**
Filter out cold sales outreach before showing priority emails.
Check sender domains and subject line patterns.

This is the compounding part. The agents get better every day because they accumulate context about how I work, what I care about, and what I don't. And because AGENT.md is committed to Git, the learnings persist across sessions.

The Integrations

The COS touches everything I use:

• Linear: Tasks, projects, priorities across multiple teams
• Google Calendar: Events from personal and work calendars
• Gmail: Priority emails from multiple accounts
• Typefully: Social content scheduling (X, LinkedIn)
• Ghost: Blog publishing and newsletters
• Google Docs: Draft review and collaboration

Each integration is a script the agents can call. The COS coordinates which agents to query based on what I'm asking.

What's Next: Team Agents

Right now, this runs my personal workflow. The agents read and write to my local repo. But the architecture is designed for teams.

The plan: agents will be able to push learnings to shared team repos. Imagine a product team where the Planning agent's AGENT.md lives in a shared GitHub repo. When one person teaches the agent something useful, everyone benefits. The team's agents get smarter together.

This is how I'm building my next company—agents that learn at the individual level, but share knowledge at the team level. Same architecture, just with shared repos instead of local ones.

More on that in a future post.