How I Use 20 AI Agents to Manage My Working Week

I attend roughly 25 meetings a week across three Microsoft partners and colleagues internally. Each one generates actions, relationships to maintain, strategic threads to track, and coaching commitments to follow through on. For months, I was drowning. Not in the work itself, but in the administration of the work. The gap between what I knew and what I could reliably recall at the right moment was getting wider.

So I built a system. And then I built another system on top of it. And then I gave that system a coaching council made up of six imaginary advisors. This is the story of how I turned an Obsidian vault and GitHub Copilot CLI into something that genuinely changed how I work, what went wrong along the way, and what I'd tell you if you're thinking of doing something similar.

The Problem I Was Trying to Solve

My job is to help three large partners build their Microsoft practices. Think tech strategy, go-to-market, skilling, security services, AI adoption, and more. It's the kind of role where the value you bring is directly proportional to how well you can connect dots between conversations that happened on different days, with different people, about different things.

The trouble is, my brain is not a database. I'd walk into a meeting with one person and forget that something we discussed with another person last week was directly relevant. I'd lose track of who I'd promised what to. I'd sit down to write a weekly update email and spend 45 minutes reconstructing what I'd actually done.

I tried OneNote. I tried Notion. I tried just being better organised (spoiler: that didn't work either). What I really needed wasn't a better note-taking app. I needed something that could take the raw material of my working life and help me think about it.

Why Obsidian, and Why AI Agents?

I landed on Obsidian because it stores everything as plain markdown files in a folder on my machine. No proprietary format. No proprietary cloud lock-in. Just text files I can version-control with Git, search with grep, and process with scripts. That last bit turned out to be the key.

GitHub Copilot CLI lets you define custom agents: small, specialised AI assistants that can read and write files, run scripts, and call external APIs. Each agent has a markdown file that describes its purpose, its workflow, and the rules it must follow. It's like writing a very detailed job description, except the employee actually reads it and does what you ask.

I started with one agent. Then two. Now I have twenty.

What the System Actually Looks Like

The vault has about 370 notes: meeting notes, daily journals, People notes (a mini-CRM of 70+ stakeholders), partner strategy hubs, project trackers, coaching sessions, and weekly reflections. Underneath, there are five layers that make it work.

20 agents, grouped by function. There's a daily operations team (scaffold meetings from my calendar, debrief them afterwards, prep briefings before important conversations, plan the week ahead). There's a knowledge management team (maintain wiki links, scan for broken references, audit vault health). There's a coaching team (more on that shortly). And there's a relationship tracker that monitors whether I'm staying in touch with the right people at the right frequency.

8 skills: shared knowledge modules that agents load when they need domain context. Things like "how does the Microsoft fiscal year work?" and "what are the wiki-linking rules for this vault?" and "how do I detect which partner a meeting belongs to?" Skills mean I write the rule once and every agent follows it.

14 Python scripts for anything that needs to be deterministic. Date calculations, name normalisation, pollen forecasts (yes, really), frontmatter parsing, partner detection. I don't trust a language model to compute fiscal years correctly. I trust Python.

External integrations via MCP servers: Microsoft 365 (calendar, email, Teams) thanks to Work IQ, Oura Ring (heart rate during meetings, readiness scores), and Open-Meteo (daily pollen levels). The biometrics are admittedly a bit of a vanity feature. But seeing that my heart rate spiked during a tense planning session is potentially useful coaching data.

Obsidian plugins tie it together: Dataview for dynamic queries, Tasks for action tracking with due dates, Templater for note creation, and Obsidian Git for automatic version control.

A Typical Day

I open my terminal and say @scaffold. The scaffold agent pulls my calendar from Microsoft 365, filters out the noise (focus time, lunch, broadcast webinars), detects which partner each meeting belongs to, normalises attendee names against my People notes, and creates pre-populated meeting note files. It also checks today's pollen level and adds it to my daily note. This takes about 30 seconds.

Before an important meeting, I run @prep Joe Bloggs. The prep agent reads Joe's People note, finds our last meeting, extracts open actions, checks coaching commitments related to the relationship, queries M365 for recent emails, and produces a structured briefing with talking points. It saves this into the meeting note's prep section so it's right there when I need it.

After the meeting, I fill in my notes (summary, key points, actions) and run @debrief. The debrief agent checks for transcript name errors, adds biometrics from my Oura Ring, tags my action items with due dates, scans for duplicate tasks across the vault, updates the People note's last contact date, and logs what it did to my daily note. If the meeting revealed something significant about a person's role or priorities, it flags the People note for enrichment.

At the end of the week, @reflect gathers all the week's data (meetings attended, actions completed, people connected with, coaching commitments tracked) and pre-populates my weekly reflection note. I still write the reflective parts myself. The agent just removes the friction of remembering what happened.

The Coaching Council Experiment

This is the part that sounds slightly unhinged, so bear with me.

I have six coaching personas: systems thinking, accountability, commercial urgency, growth mindset, marginal gains, and behavioural transition. They run as separate agents, orchestrated by a coach agent that conducts a Delphi-style deliberation across all six perspectives. The output is a coaching session with a scorecard tracking six dimensions over time.

Does it work? Honestly, more than I expected. The scorecard trajectory over nine sessions has been genuinely useful for spotting patterns I wouldn't have seen myself. My "Follow-Through" score dropped for three consecutive sessions before I noticed and took it seriously. The different lenses catch different things; process decomposition questions are completely different from accountability challenges.

Is it overkill? Absolutely. Six personas is too many for the signal they produce. If I were starting again, I'd pick three. But the coaching data has become one of the most valuable parts of the vault, and the commitments I track through it have directly influenced real decisions at work.

What I Got Wrong

Quite a lot, actually.

I built the system instead of doing the work. For the first few weeks, I was spending more time refining agent prompts, writing scripts, and tweaking templates than I was actually using the vault for its intended purpose. My coaching scorecard flagged this. Follow-Through was my weakest dimension, and the irony of building a follow-through tracking system while not following through on actual commitments was not lost on me.

I over-indexed on observability. Agent activity logs, health audits, consistency checks, relationship scoring. I could see everything about the state of my vault. But observability without action is just a prettier way of procrastinating. The dashboard was green. The work wasn't done.

Weekly reflections died. I built an entire reflect agent with data gathering, pre-population, and contextual prompts. Then I didn't use it for five months. The daily notes were raw ore that never got smelted. I've since restarted, and the reflect agent genuinely helps, but the gap taught me that tooling doesn't create habits. Habits create habits. The tooling just reduces friction.

Name resolution is harder than you'd think. Speech-to-text transcripts mangle names constantly. I've built a corrections memory system and a name normalisation script, but it's a never-ending battle.

What I'd Tell You

If any of this resonates, here's what I've learned.

Start with one agent, not twenty. The debrief agent is the single most valuable thing I built. If you do nothing else, build something that processes your meeting notes after the fact: tags actions, links people, updates your CRM. The compound value of consistent post-meeting processing is enormous.

Externalise computation to scripts. Don't ask a language model to calculate dates, detect partners from attendee lists, or parse YAML frontmatter. Write a Python script. It'll be right every time, and you'll never wonder whether the agent hallucinated a fiscal year.

Design for the lazy version of yourself. If the system requires you to remember to run something, you won't. The best parts of my setup are the ones where I type one command and the agent handles everything else. The worst parts are the ones that need me to manually maintain them.

Be honest about whether you're building or using. There's a fine line between productively improving your system and using system improvement as a form of avoidance. If you haven't written a weekly reflection in five months but you've refactored your agent architecture three times, you might be on the wrong side of that line. I certainly was.

It doesn't have to be this complex. My vault has 20 agents, 8 skills, 14 scripts, and integrations with three external services. Most people would get 80% of the value from an Obsidian vault with Dataview, a good daily note template, and one well-written debrief agent. The other 19 agents are diminishing returns. Enjoyable, useful, occasionally brilliant diminishing returns. But diminishing returns nonetheless.

Try It

If you're curious, everything I've described runs on GitHub Copilot CLI with custom agents defined as markdown files. Obsidian is free. The scripts are Python stdlib with no pip dependencies. The whole thing is version-controlled in a private Git repo that syncs across my devices.

I'm not suggesting you build what I've built. I'm suggesting you look at the gap between what you know and what you can recall at the right moment, and ask yourself whether a well-structured vault with a couple of AI agents might close it. For me, it did. Not perfectly, not without wrong turns, but meaningfully.

I'd love to hear if you're doing something similar, or if you have questions about any of this. Drop a comment, or find me on LinkedIn.