My AI chief of staff experiment

I've been working with an AI Chief of Staff for the past three weeks.

It's a proper system that knows my business, remembers everything, fixes itself when it breaks, and ships real work every day. It runs client reporting, builds workflows, reconciles financial data, analyses sales calls, and flags problems before I see them.

Three weeks ago, I was using AI to write LinkedIn posts and clean up copy. Today, it's running half my operations.

The problem I was trying to solve

I run AscendAI - LinkedIn-led pipeline generation for professional and financial services firms. Every client gets content, outbound campaigns, inbound lead qualification, and monthly reporting.

The delivery works, clients are happy, but I was drowning in operational detail.

Every week I'd spend hours reconciling data, building reports, checking which clients were at risk, remembering what we promised in the last sales call, and tracking what worked and what didn't.

Every task required me to remember where we left off, what the client's ICP was, what campaigns were running, and what the last report said.

I needed a system that could hold all of that in its head and act on it.

What I built

So I built a Chief of Staff agent with three core capabilities that actually make it useful.

1. It remembers everything

The system maintains a living business state file. Active clients, MRR, pipeline deals, contract end dates, churn risk, outstanding invoices, strategic decisions - all in one place.

Every session, it reads that file first. It knows where the business stands without me explaining it every time.

When something changes - a client churns, a deal closes, a strategic decision gets made - it updates the file automatically. I don't have to remind it. It just knows.

2. It fixes itself when it breaks

This week, I asked it to build a pre-call email flow for prospects who book meetings. The first version failed because the trigger logic was wrong, and the second email never sent.

Instead of waiting for me to catch the error, it spotted the problem, rewrote the flow, and documented what went wrong so it wouldn't happen again.

It calls this "self-annealing." When something breaks, it reads the error, fixes the code or workflow, tests it, and updates the system documentation with what it learned. There's no hand-holding or babysitting. Just continuous improvement.

3. It ships real work every day

Here's what we built together this week:

• Pre-call email flow: a two-email sequence that sends automatically when prospects book meetings. Email 1 explains what we do. Email 2 - sent one day before the meeting - shares proof: a case study and a redacted client report. A significant improvement on the prior pre-call flow.
• Transcript analysis system: centralises all the Fireflies recordings from sales calls, extracts the lead's pain points, scores the meeting quality, flags action items, and writes a ready-to-send follow-up email with the proposal link. The key is pattern recognition across all files to figure out what's working and what isn't.
• Client reconciliation: we had conflicting active client counts across different sources. It went through every file, reconciled the data, flagged the discrepancies, and gave me a single source of truth.
• Month-end reporting system: a full Python-based automation that pulls data from four different sources, matches posts to their performance data, aggregates inbound signals, tags content features, and generates client reports and internal insights.
• Google Analytics integration: automated website metrics collection for weekly performance reports. Saves five minutes a week, but more importantly - no more copy-paste errors or inconsistent formatting.

The three principles that made this work

1. Skill-first, not prompt-first

Most people think of AI as better search or smart autocomplete. You ask it to do something, it does it, you move on. That doesn't scale.

I built a library of skills - repeatable workflows with clear inputs, outputs, and success criteria. Newsletter writing. Client reporting. Sales call analysis. ICP matching. Outbound campaign design.

Each skill knows what context it needs, what files to read, what format to deliver, and what to do when it fails.

The Chief of Staff doesn't wait for instructions. When I say "write this week's newsletter," it knows to pull the newsletter skill, load the sales context, review past performance data, check the tone and style examples, and deliver a draft that matches my voice. I then work through it with the system, paragraph by paragraph, until I'm happy. There is still work from my side, for sure - but the workflow is structured, I save time, and the outputs get better. This same approach underpins the outbound tool we ended up building ourselves.

2. Living context, not static instructions

The system maintains five core context files:

• Business state (clients, MRR, pipeline, cash position, strategic decisions)
• Sales context (ICP, offers, messaging principles, proof points)
• Client-specific context (brand voice, content pillars, campaign history)
• Skills index (what workflows exist and when to use them)
• Session log (what we did, what we learned, what broke)

Every time it does work, it updates the relevant files. Every session starts by reading the current state.

This means it gets smarter over time. It learns what works for each client. It remembers which prospects went cold and why. It tracks which content formats drive the most ICP matches.

Most AI tools forget everything the moment you close the window. This one compounds. If you've read about why knowledge workers are switching to Claude, the compounding context point is exactly why.

3. Self-annealing, not hand-holding

When something breaks - and it does break - the system doesn't wait for me to fix it.

It reads the error message, identifies the real failure (bad input, missing file, wrong logic, edge case), patches the workflow, tests the fix, and updates the documentation so the same problem doesn't happen again.

This week, it built a month-end reporting system that failed on the first run because the date format in one CSV didn't match the expected format. Instead of stopping, it caught the error, adjusted the parsing logic, re-ran the script, and documented the edge case.

The system got better without me touching it.

What this actually looks like in practice

Here's a real example from this week.

I had a sales call with a prospect. Good conversation, they were interested, but I needed to send a follow-up with the proposal and some proof points.

The old way would have me spending 20 minutes re-listening to the call, pulling out key pain points, drafting a follow-up email, finding the right case studies, and remembering what I promised to send.

Now I upload the Fireflies transcript, and the Chief of Staff analyses it, scores the meeting quality (7/10 in this case - good fit, clear pain, budget unclear), extracts the three main pain points, flags the action items, and writes a follow-up email ready to send. It even suggests which case study to include based on the prospect's sector.

Total time: 2 minutes.

It picks up things I would have missed - especially when it analyses the specific transcript in relation to its knowledge of that particular domain. You can see a version of this output-to-pipeline loop in our Vuna case study, where consistent, informed outreach compounded into a measurable pipeline result.

The bottom line

Today, my AI Chief of Staff is a colleague I work with every day. It doesn't do everything, but it does half my operations. And it's getting better every session.

If you're running a small professional-services business and still using AI only for writing, you're leaving most of the leverage on the table. The shift from prompt-based to system-based is the one that actually changes how the business runs.

Frequently asked questions

What is an AI chief of staff and how does it work?

An AI chief of staff is a system built around a large language model that maintains a living business state file, executes repeatable skill-based workflows, and updates its own context after every session. Unlike a chat tool you prompt once and move on, it reads where the business stands before it acts, ships real deliverables, and documents what it learns when something breaks - so it compounds rather than resets.

What kinds of tasks can an AI chief of staff actually handle?

Based on this experiment: pre-call email sequences, sales call transcript analysis and follow-up drafting, client data reconciliation across multiple sources, month-end reporting built from four data sources, and automated website metrics collection. The common thread is tasks that are repeatable, context-dependent, and time-consuming when done manually.

What makes an AI workflow compound over time rather than reset?

Three things: a living context that gets updated after every session (not static instructions that go stale), skill-based workflows with clear inputs and success criteria rather than one-off prompts, and a self-annealing loop where the system reads its own errors, patches the workflow, and documents what it learned. Each session starts smarter than the last.