Last week I wrote about how I structured my agents to learn—the two-file system, the feedback loop, the accumulation of knowledge over time. But the technical architecture is only half the story.

The more interesting part is what happens when agents actually learn.

Something shifted after the first few weeks. My agents stopped feeling like tools and started feeling like collaborators. Not because they got smarter—because they got context. They remembered what I cared about. They knew my preferences before I stated them. They pushed back when my priorities drifted.

This changes the relationship.

When you know your feedback will stick, you give better feedback. You're more precise. You explain the "why" because you know the agent will use it next time. I've become a better delegator because my agents hold me accountable to my own standards.

The learning runs both ways. My planning agent asks hard questions—not because it's programmed to, but because it has accumulated months of context about what I'm trying to accomplish. It notices when my weekly goals don't align with my quarterly priorities. It flags when I'm avoiding something important.

I didn't expect to be coached by my own agents. But that's what's happening.

This is what separates a demo from a system you rely on. Demos are impressive once. Systems that learn become indispensable because they encode everything you've taught them. The cost of switching isn't the technology—it's the accumulated context you'd lose.

I think about this in terms of the future of work. Right now, when you leave a job, you leave behind relationships and institutional knowledge. Imagine if you also left behind an agent that had learned exactly how you operate—your communication style, your decision-making patterns, your priorities.

That agent would be valuable. Not just to you, but to whoever works with you next.

We're heading toward a world where people don't just bring their skills to a role—they bring their agents. And the value isn't just in what they know. It's in what their agents have learned.

Most AI agents have amnesia. Every conversation starts fresh. You teach them something useful, and by tomorrow it's gone.

I wanted agents that actually get better over time. Not through fine-tuning or retraining—through structured learning from use. Here's how I built it.

The Two-File System

Every agent in my system has two files that make learning work:

AGENT.md is the agent's durable knowledge. It defines the role, workflow, integrations, and—critically—an "Accumulated Learnings" section at the bottom. This is where permanent knowledge lives. Things like:

• Workflow rules ("always prioritize shipping over planning")
• Technical knowledge ("use UTC timestamps for scheduling")
• Strategy guidance ("filter out cold outreach before showing priority emails")

This file is committed to Git and versioned. When I teach an agent something that should change how it works forever, it goes here.

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

The split matters. Some knowledge is universal (put it in AGENT.md, share it). Some knowledge is personal (put it in memory.md, keep it private).

How Learning Actually Happens

When I give feedback—"that's not a priority," "do it this way instead," "never show me those emails"—the agent figures out which file to update.

Workflow changes go to AGENT.md:

### Accumulated Learnings

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

**Priority Logic (2026-01-20)**
When surfacing tasks, always put "Complete" items first,
then "Advance" items, then "Consider" items.

Personal context goes to memory.md:

### Notes

- Prefers morning standups before 9am
- Currently focused on Q1 launch
- Skip calendar items tagged "optional"

The key: every learning is dated and specific. Not vague principles—concrete rules the agent can apply.

Why Structure Beats Intelligence

The smartest model in the world is useless if it forgets what you told it yesterday. Structure creates persistence.

Here's what I've learned building this system:

1. Narrow beats broad. An agent with a single job and deep memory outperforms a generalist with no context. My Calendar agent only does calendar. But it remembers every preference I've ever expressed about scheduling.

2. Examples beat instructions. Instead of telling an agent "write good emails," I show it examples of emails I liked. Those examples live in AGENT.md, and the agent references them every time.

3. Corrections compound. Every time I say "not like that," the agent gets better. After a few weeks, the corrections are rare because the agent has learned what I actually want.

The Feedback Loop

The system creates a tight feedback loop:

1. Agent does something
2. I react (good, bad, or "do it differently")
3. Agent updates the right file
4. Next time, agent does it better

This is how humans learn too. We try, get feedback, adjust. The difference is my agents write down every lesson so they never forget.

What's Next

Right now, each agent learns independently. My Calendar agent doesn't know what my Email agent has learned. The next step: shared learning across agents.

Some knowledge should propagate. If I tell my Email agent "this person is high priority," my Calendar agent should know that too. That's the architecture I'm building toward—agents that learn individually but share knowledge where it makes sense.

More on that in a future post.

Last week I wrote about my Chief of Staff agent—a system that orchestrates specialized agents across my calendar, email, tasks, and content. It's changed how I work. But the bigger idea is what comes next.

My agents are starting to work with other agents.

Right now, it's simple: my Calendar agent coordinates with a colleague's scheduling system. My Content agent pulls context from a shared repo. But the pattern scales. Imagine teams where everyone has their own agent organization, and the agents collaborate with each other—sharing context, coordinating tasks, learning from each interaction.

This changes how we think about talent. In the future, you won't just be hired for your skills. You'll be hired for how experienced your agents are. How many decisions they've made. What systems they've integrated with. What other agents they've collaborated with. We'll see a new kind of "agentic firm"—individuals or small teams with battle-tested agent organizations, hired not by salary but by usage. The value isn't just in what you know. It's in what your agents know, what they've done, and who they've worked with.

I'm building my next company this way from day one. Agents that learn at the individual level, share knowledge at the team level, and compound over time. That's the new leverage.

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.

Everyone's talking about the 1000x engineer. What about the 1000x non-engineer?

I've been building personal agents for the past few weeks. A Chief of Staff agent that orchestrates my day. A Content agent that plans and schedules my writing. A Calendar agent, an Email agent, a Planning agent that tracks my goals. They work together, learn from my feedback, and compound over time.

This isn't about engineering. It's about marketers, operators, founders, finance teams, sales teams, product managers—anyone who does knowledge work. The same leverage that's transforming software development is coming to every function.

The companies that embrace this will operate differently. Agents doing research, analysis, planning, execution—the full loop of work, not just pieces of it. People focused on judgment, strategy, and creativity. My next company will be built this way from the start.

Build agents that learn. Build systems that compound. That's the new job.

This blog post was written almost entirely by an agent.

Not a chatbot. Not a one-shot prompt. An agentic workflow—a system of specialized agents that read context, make decisions, and execute across multiple tools and services.

I've been building personal agents for the past few weeks. A Chief of Staff agent that runs my daily standup. A Content agent that plans and schedules my posts. A Calendar agent that manages my schedule. An Email agent that triages my inbox. A Planning agent that tracks my goals. They all work together.

Here's what the architecture looks like:

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

Each agent has its own folder with an AGENT.md file that defines its role, workflow, and accumulated learnings. When I give feedback, the agent updates its memory. It learns.

The integrations span everything I use: Linear for tasks, Google Calendar for scheduling, Gmail for email, Typefully for social content, Ghost for blogging. The agents read from these services, make decisions, and write back.

What surprised me most: the best systems are the ones you forget exist. I don't think about scheduling content anymore. I don't manually triage email. The daily standup just happens.

This changes how I work. It'll change how teams work. Companies built from the ground up with agents won't look like companies today—fewer people doing more, with agents handling the coordination layer that used to require meetings, status updates, and manual handoffs.

Every Friday, I'll share what I'm building. Code, architecture, learnings. This is the first.