Ask any TPM how they keep a program on track and you'll probably hear about trackers: a roadmap tracker, a risk register, a decision log, a launch checklist and a status report template. Then you multiply that by every workstream you run.
I'm a solo TPM running operations for the Switch AI team across five workstreams. For a long time, that meant a million trackers and one of me keeping them alive.
Switch pushed me into a modern way to program manage. I don't build more trackers now. I build agents, and they do the work the trackers were supposed to do.
The Old Way: The Trackers
For years, a TPM's job was to turn strategy into execution, and the execution side always looked the same: planning, more planning, tracking delivery, and building and implementing processes. When the train came off the rails, I steered it back toward its destination. I aligned every stakeholder, resolved blockers across orgs, designed org-wide processes, trained everyone on them, rolled them out and made sure people followed every single step.
Two of those jobs took up most of my time.
The first was tracking and reporting. That meant gathering information, writing it up, sending it to stakeholders for review, chasing them for comments, folding in corrections and only then publishing. A tracker doesn't know anything until someone updates it, and on a fast-moving team the only person updating it is the TPM. By the time a report made it through review, what it described had already changed.
The second was building and managing org-wide processes. I'd design a process for the whole org, write the SOP, train everyone on it, roll it out and then spend months making sure people actually followed every step. A process is only as good as the person running it on their worst day, and it's easy to skip a step under pressure.
Both were essential, and both took me away from actually running the program.
What Switch Changed for Me
Switch gives agents and humans shared rooms with the same context, the same history and the same resources. Once I started working that way, my questions changed. I stopped asking which tracker a piece of information belonged in. I started asking whether an agent could gather it, put it together and keep it current for me.
Most of the time, the answer was yes.
Modern program management, for me, means designing the systems instead of feeding the trackers. I decide where information comes from, what the agent should do with it and where a human needs to step in. Then I let the agents run.
Here are three examples from my day-to-day.
How I Actually Use Switch Every Day
Incident response, run by multiple agents and multiple humans together

In my old TPM days, incident management was a manual checklist that I ran myself. When an alert fired, someone had to figure out whether it was a real issue. If it was, I'd spin up a Slack war room, pull in the right people, start a meeting, write an hourly update for senior leaders and, once it was all over, write the RCA from memory and chat history.
Oliver Bazely and I automated it, and the result is a team, made up of people and agents working the same incident in the same room.
When a suspicious alert lands in Slack, an agent evaluates it first to decide whether it's a real issue or just noise. If it's real, a human declares the incident. We kept that decision with people on purpose.
From there, my agent runs the process we designed together, the same one I used to run by hand. It kicks off a Slack war room, starts the meeting, sends hourly updates to our senior leaders and writes up the RCA for the team to review.
This used to be the hardest part of rolling out any process: writing the SOP, training every on-call engineer, then hoping that in the middle of an outage someone remembered to post the leadership update. Now the process lives inside the agent. It follows every step, every time, and nobody has to refer to a checklist while they're fighting a fire.
Then Oliver brings his own agent in to triage and resolve the issue. Engineers from different teams hop on the call to help. At any moment, the war room has several humans and several agents working side by side. My agent runs the process and communications, Oliver's agent digs into the technical problem, and the engineers make the calls only people should make.
What makes this work is that everyone shares the same context. Oliver's agent doesn't need a briefing, because it reads the room and gets to work. An engineer who joins halfway through can scroll up and see everything: the alert, what's been tried and what the agents found. Nobody has to stop and catch anyone up, human or agent.
Most AI tools give you one agent working for one person. Incidents don't work that way. They take a team, and with Switch, that team includes agents.
Humans make the judgment calls and agents handle everything around them. No one has to stop fixing the problem to write an update.
Status reports that write themselves

Here's how status reporting used to work. I had a weekly sync with the team, which is great for alignment but only happens once a week. Everything in between happened in Slack or in ad-hoc meetings: developers and product managers working through problems, making calls in threads, flagging risks in passing and quietly shipping things.
So to write a status report, I'd crawl through all of those Slack conversations and piece together a draft. Things got missed, because no one can read every thread across five workstreams. Then I'd chase people to review the draft. By the time I'd tracked everyone down and folded in their corrections, the report was already out of date.
Now a Switch room does that work. It collects the Slack conversations between our developers and product managers and picks out what matters: what shipped, what got decided, what's at risk and what's blocked. Every day it posts a summary.
I don't crawl through threads, and I don't wait for the weekly sync to know what's going on. Information no longer slips through because I happened to miss a thread. There's no review round to chase, either. The summary comes straight from what developers and product managers actually said in Slack and in meeting transcripts, not from my reconstruction of it, so there's nothing to correct and no time for it to go stale. The update is daily instead of weekly, and it's current when it lands.
Onboarding my new manager without a single spreadsheet

When Robert joined as my new manager, one of the first things he asked me was a very reasonable question: where can I look for progress, blockers and risks on current programs?
He asked my counterpart in another org the same question. The two answers he got couldn't have been more different, and that contrast stuck with me.
My counterpart, who has not yet adopted using Switch, handed him four giant spreadsheet trackers, which is still the usual answer in most orgs. Meanwhile, I added him to the Switch room and guided him to ask the agent his questions.
There was no walkthrough of tabs and no decoding of someone else's color-coding. Robert sees the same daily summary as the rest of the team, and the agent in the room already has the full history behind it. If he wants to know why something slipped, who owns a risk or what got decided last week, he asks and gets an answer, without having to wait for me.
That's the difference between a tracker and an agent. A tracker shows you whatever someone last typed into it. An agent can answer your actual question.
This Is the Modern Way to Run Engineering Operations
Engineer operations have always been about making sure the right people have the right information at the right time. For years, the way to do that was trackers and review cycles for reporting, and SOPs and training sessions for process, with a TPM in the middle keeping it all alive.
Look back at the three stories and the pattern is the same. The status report is written from what people actually said. Robert gets answers by asking, not by decoding someone else's spreadsheets. The incident runs the way Oliver and I designed it, while his agent works the problem. Each time, an agent does the gathering, the writing and the follow-through, and a person makes the calls that matter.
That's the job now. I design how it all fits together, and I step in where human judgment matters, like steering the train when it really does come off the rails.
I still run five workstreams on my own. I just don't do it with a million trackers anymore.
If you're a TPM drowning in spreadsheets and chasing people for updates, set up a Switch room and see what changes.
Reach out for a demo to see how Switch works for your team's workflow, or get started directly with the open source version at https://github.com/sandbox-quantum/switch.




