Seven Clicks a Day, Forever

I built a three-skill pipeline so I’d never have to “Download transcript” again. The pipeline isn’t the point.

I record a meeting with myself every day.

It’s not a meeting. It’s me, at my desk (or in the car, or on a run), talking out loud to Teams for fifteen or twenty minutes about what I’m trying to do that day: the threads I’m pulling on, the half-finished decisions from yesterday, the things I’m worried about, the projects I need to start or finish, the things I’m excited about. I hit record, I talk, I hang up.

Then Teams transcribes it. And that transcript is gold. Because it isn’t notes I had to type. It’s me, thinking out loud at the speed of speech, in my own voice, with all the messy connective tissue that I never bother to write down. It is the single richest piece of context I can give to my agent for the rest of the day.

But to get it into the agent’s hands, I had to do this every time:

Open Teams.
Find the meeting in the chat.
Click into the recap.
Open the transcript pane.
Click the three dots, click Download, pick .docx.
Convert to txt so the agent can really consume it.
Move the file from Downloads into the folder my agent watches.

Seven clicks. Every day. Forever.

That’s the kind of friction that kills a workflow before it has a chance to compound. I knew it. I felt it every morning. And every day I did those clicks anyway, because the payoff was worth it. Many days, more than once.

I’ve done this for months, and couldn’t build a way around it, until now.

The real point isn’t the meeting

I want to be honest about what this project actually was, because the surface description (“I automated Teams transcript downloads”) sells it short.

The point is not that downloading a Teams transcript is hard. It isn’t. It takes less than a minute.

The point is that a manual task done every single day, forever, is the single most expensive thing you can put in your workflow. Not because of the minute it takes. Because of the decision cost: the tiny moment every time where I have to remember to do it, choose to do it, and then mentally context-switch out of “I’m about to work” into “I’m doing data plumbing.” That decision cost is what kills the workflow. The transcript stops happening. The agent stops getting the context. The agent’s outputs get worse. I notice. I get frustrated.

The fix wasn’t a better agent. The fix was making the input arrive without me.

The constraint that shaped everything

The clean version of this is one Graph API call. GET /me/onlineMeetings/{id}/transcripts/{id}/content returns the .docx. It’s a one-liner.

It’s also blocked in my tenant. Admin consent on OnlineMeetingTranscript.Read.All is not happening. Nobody is going to grant that permission to one rando in a 200,000-person tenant. The answer was no, and the answer is going to stay no, and that’s fine; I’m not building a product, I’m building a workflow for me.

So the entire design had to assume that the only reliable way to get a transcript is to drive the Teams web UI like a human would. Playwright. Click the buttons. Wait for the download. Move the file.

Once you accept that constraint, the shape of the solution starts to come into focus.

Three skills, one pipeline

I broke the work into three pieces, each doing one thing, each independently useful.

Stage 1: /transcript-watcher polls my OneDrive Recordings folder every thirty minutes. Teams puts a new MP4 there every time a recorded meeting ends. When the watcher sees a new file whose name matches one of my watched series prefixes, it knows there’s a transcript to go get. It pings me in Teams (“I see a new recording for X, going to grab the transcript”) and invokes the next skill. The expensive thing (Playwright) only runs when there’s actual work.

Stage 2: /meeting-transcript is the Playwright driver. It opens Teams in a real browser, finds the meeting in the chat, opens the transcript pane, clicks Download, waits for the .docx, and saves it to a watched folder with a sensible filename. This is also the skill I can invoke directly when I want a transcript for a meeting that happened weeks ago.

Stage 3: /doc-watcher watches the folder. When a new .docx lands, it converts it to plain-text Markdown using Word COM (headless), pings me in Teams that it’s ready, and the original .docx never gets touched.

End to end: about thirty minutes typical, an hour worst case (the recording has to finish processing in OneDrive before stage 1 can see it). Zero clicks from me. If I want it right now (I usually do), I kick it off manually. Soup to nuts in three minutes.

The Markdown file lands in the same folder my agent reads at the start of every conversation. The agent sees this as ambient context. It knows what I was worried about. It knows what threads I’m pulling on. It knows what I’m trying to do that day. I didn’t have to tell it. I just had to talk.

The gotcha that confused me

One detail almost broke the whole thing.

The Recap picker in Teams shows the scheduled meeting time, not the actual recording start time. So my standing one-on-one with myself is scheduled at 18:45, but I actually hit record at 12:20, and the file the pipeline produced was named with 18:45. I do this more than once a day, so multiple files collided because they were all “scheduled at 18:45.”

The fix was to stop trusting the Recap picker and read the recording start time out of the chat thread instead. Three regex cases (English UI, localized variants, edge formatting) cover everything I’ve seen. The skill warns loudly if it falls back to the picker’s value, so I’ll notice if a fourth case shows up.

A workflow you can’t trust is a workflow you’ll abandon. Naming has to be right or none of the rest of it matters.

What this actually unlocked

The transcripts arrive. The agent reads them. I haven’t clicked “Download transcript” once.

What I didn’t expect was the second-order effect. Because the friction went to zero, I started recording more things: short voice memos between meetings, a five-minute postmortem after a hard call, a quick “here’s where I left this” before I close the laptop. All of it ends up as Markdown in the same folder. All of it becomes context.

The pipeline removed seven clicks. Removing those clicks made me record three times as often. The agent’s context window got an order of magnitude richer. Jevons’ paradox in action.

That’s the trade I want to keep making: find the daily friction, automate it down to zero, then watch the behavior on the other side of the friction explode.

The three skills are live

All three are published on SkillWorks if you want to lift them. They’re Clawpilot skills: install them with /install, configure your paths, and you’re running. They should work fine with GitHub Copilot, Copilot CoWork, or other systems with minor modifications. Ask your agent to adjust them.

Teams Transcript Pipeline: the full write-up (the why, the design, the dead ends)
/transcript-watcher: polls OneDrive for new recordings
/meeting-transcript: drives Playwright to pull the .docx
/doc-watcher: converts .docx to plain Markdown and pings you in Teams

Each one is independently useful. The doc-watcher in particular has nothing to do with Teams. Point it at any folder of Word documents and you’ve got a feed of plain-text copies that your agent can use.

Your turn

What’s your seven-clicks-a-day workflow? The one you’ve been doing forever because the payoff is worth it, but the decision cost is starting to fray?

Drop it in the comments. Half the time I see somebody else’s, I realize I have the same one and didn’t notice.

More of what I write lives at signalnotsentiment.com. Lessons from doing, not theorizing.

Phone in the Truck

Why I think we’re nowhere near as far along on the AI curve as it feels.

I’m old enough to remember the time before cell phones.

I had a phone on my desk at work. I had a phone at home, the one with the long curly cord, attached to an answering machine that I rewound by pressing a tiny tape down with my thumb. That was the communication stack. That was it. Different numbers, different functions.

Then I got my first cell phone. And it wasn’t really a phone, not the way you’re picturing it. It was a handset bolted to the console of my Chevy S-10, right next to the gear shift. A cord ran from the back of it down into the dash for power. The buttons were on the back of the handset. You could pick it up and put it to your ear like a regular phone, or you could leave it cradled and hit speaker.

I thought I had arrived.

For the first time in my life, the dead hours of a commute became productive hours. Driving to a meeting, driving to a sporting event, driving home late, I could communicate. I told everyone I knew that this thing had changed my productivity forever.

It had. It just wasn’t what I thought it was.

Every stage looked like the peak from the inside

Then Nokia happened. The flip phone. The bar of soap phone. Auto-answer with a headset jack, which felt like science fiction, because now I didn’t even have to reach into my pocket. If it rang, I started talking. Productivity unlocked. Again.

Then keyboards. BlackBerry. Windows Mobile. Email in my hand. I remember thinking, this is it, this is the force multiplier. What more could you possibly need?

Then the iPhone. Apps. Then data, slow and unreliable at first, but a web browser in your pocket, which was a concept that had not existed before. Then real apps. Then Bluetooth, which we all made fun of until every single one of us was wearing it. Then video calls. Then maps that knew where you were. Then a bank in your pocket. Then a camera better than the one in my closet.

At every single one of those stops, I thought we had arrived.

I was wrong every single time.

The phone in my truck and the phone in my pocket today are not the same product. They are not the same category. They are barely the same species. And the version of me sitting in that truck in 1992 could not have described to you what the device in my pocket is today, because the words for it did not yet exist.

Now look at AI

I have a fleet of agents working for me right now.

One of them triages my inbox before I’m awake. One of them rewrites my drafts. One of them sits on my calendar and resolves conflicts before I see them, then sends me a morning report telling me what it moved and why. One of them builds dashboards on demand. One of them runs a weekly report on how many tokens I burned, how many artifacts got produced, and a rough estimate of how many hundreds of thousands of dollars of human effort would have been required to do all of that two years ago.

I am, by any reasonable measure, more productive than I have ever been.

And every time I demo a piece of this to someone, the reaction is the same. This is incredible. This is the future. We must be so close to the peak.

I keep wanting to agree with them. I have lived inside the productivity gain. I know what it feels like.

But I’ve been through this movie before.

We’re in the S-10

We are not at the iPhone moment of AI. We are not at the BlackBerry moment of AI. I don’t think we’re at the Nokia moment of AI.

I think we’re at the phone in the truck.

I think the version of AI my kids are going to use in a decade is going to be as unrecognizable to us, sitting here in 2026, as a modern smartphone would have been to me sitting in my truck in 1992. The words for it don’t exist yet. The form factor for it doesn’t exist yet. The social patterns for it don’t exist yet. We don’t even have the right complaints yet, and complaints are usually a leading indicator that a category is mature.

The exponential nature of this curve fools us. It feels like we’re moving so fast we must be near the end, when in reality the speed is the tell that we’re near the beginning. Things move fastest when they have the most room left to run.

The fact that the pace has compressed does not invalidate the pattern. It just means we’re going to see the next several stages inside a single career instead of across three of them.

So when somebody asks me where we are on the AI curve, I have a real answer now.

I’m in the truck. The cord goes into the dash. The handset is next to the gear shift. And I am absolutely certain I have arrived, in exactly the way I was certain the last four times.

Your turn

Where do you think we are on the AI curve? Phone in the truck? Nokia flip? BlackBerry? Early iPhone? Something later?

Drop your honest answer in the comments. Bonus points if you can name the feature you’re using today that will look as quaint in ten years as a handset bolted to a dashboard looks now.

Lessons from doing, not theorizing.

Step 7: We Almost Broke Everything

📍 Part 7 of 8 · Becoming Agent-Native
An 8-part series on going from delivery team to agent-native organization — lessons earned, not borrowed.
Genesis · Anxiety · Names Matter · Proof of Value · The Pivot · Co-Creation · → The Garage · The Flywheel

Let me describe the period just before we built the Garage.

High creativity. Great energy. Agents proliferating across the team.

Underneath it: loose operational foundation at best. Governance ideas and concepts.

Flailing.

Here’s what “flailing” actually looked like:

Seven agents doing roughly the same thing. No design pattern to rationalize them. A delivery team member builds an agent, it works great, she goes on vacation, the model updates, it breaks, nobody knows who to call.

Some agents didn’t log to the dashboard. Some logged multiple entries. Some logged events for failed runs. Agents that hadn’t been through a security review. Agents that got stuck in loops and churned resources. Agents without error handling.

None of it malicious. All of it predictable.

Momentum without infrastructure eventually produces exactly this.

What the Garage is.

The name is intentional. The Garage is where things get built right; maintained properly, run reliably, tuned up occasionally, extended thoughtfully.

The core insight: every agent, regardless of who built it or how fast it came together, needs to meet a consistent baseline.

Usage logged to the central dashboard
Security parameters and data governance verified
Responsible AI framework compliant
Clear ownership with a maintenance plan
No unnecessary overlap with existing agents
Fit into the software development lifecycle

Before the Garage, those things happened by luck. After the Garage, they happen by design. They were all documented in the Garage Green Book.

The thing we were most careful not to break.

The creative momentum from Phase 5.

The worst version of an agent ops team is one that becomes a bottleneck. Submit your agent request here. Six-week review cycle. Fill out this form in triplicate. You missed section 17 of the BRD. How did you come up with that ROI. We need LT buyoff. Thank you for your patience.

That kills everything. Literally everything. Momentum, creativity, usage, passion; everything.

So we designed what we think of as a barbell.

One side is the delivery team: the ideation, the domain expertise, the speed, the ideas born from real work. To quote my mentor “In the business, not on the business”

The other side is the Garage: the rigor, the telemetry, the governance, the scale.

Both sides need each other.

Delivery without ops builds fast and breaks things. Ops without delivery builds carefully and solves the wrong problems. Together: fast and right.

What good agent ops actually enables.

It’s not just about catching problems.

Operational infrastructure is what makes scale possible. When the process for onboarding a new agent is defined, you can move faster. When agents share a common architecture, you can combine them. When the foundation is solid, extensions are fast. When your telemetry is accurate, you get buy in and more funding.

The Garage isn’t friction for innovation. It’s the launchpad.

One more thing the Garage gave us: a real answer to “what agents do we have, what do they do, and who owns them?”

That’s not glamorous. It’s essential. It’s an incredibly valuable asset. You need a library of agents, an agent to search that library, and an agent to simplify the process for getting more agents into the library. That’s agent ops. That’s The Garage.

Agent ops is a real thing. If you’re scaling agents without it, you’re not running a program. You’re running a mess.

Next: What the whole system looks like when it’s actually working.

Step 6: The Phase Nobody Plans For

📍 Part 6 of 8 · Becoming Agent-Native
An 8-part series on going from delivery team to agent-native organization — lessons earned, not borrowed.
Genesis · Anxiety · Names Matter · Proof of Value · The Pivot · → Co-Creation · The Garage · The Flywheel

When we started, the model was simple.

Squad builds. Delivery uses.

That division felt right. Clean organizational lines. Clear ownership. A good model.

By Phase 5, it was gone, and it was the best thing that could have happened.

Delivery became builders.

Not because we told them to. Not as a program or initiative.

Organically…as the natural result of everything that came before.

People moved through the anxiety, saw agents make their days better, made the mindset shift from threat to tool to teammate. They started showing up with more than feedback. They showed up with half-built ideas. With sketches of agents they needed. With “I figured out how to make this work”

And with a low-code toolkit they built them. Themselves.

Why this works better than centralized roadmaps.

The people doing the work every day know the friction better than anyone. They know which task is genuinely painful versus just annoying. They know which data lives in the wrong place. They know what “good output” actually looks like for their specific context. They aren’t looking at a PowerPoint slide or a Figma, they are living the experience.

When they build the agent, it fits because it was designed by someone in the workflow it’s automating.

Mona is a great example. She didn’t come from a squad roadmap, she came from a delivery team member who was tired of the back and forth with humans scheduling meetings. She understood the problem completely. She had opinions about exactly what the output should look like. She came to demo days and the engineers said “that’s a great idea but it won’t work” and then she showed them the MVP…working. That day changed our world.

That’s the model. You can’t push it from the top down. It has to grow

The propagation effect.

When everyone in delivery is creating, velocity compounds. One agent spawns an idea for three more. A tool that worked for one person gets adapted for the whole team. The surface area of “problems we’ve automated” expands faster than any squad sitting in an ivory tower could imagine.

There’s not some special team that’s the only one creating. Everyone is. That’s the whole point.

The catch.

There is one. And it’s significant enough to become its own post.

When everyone is building, you get overlap. You get orphaned agents when the person who built them goes on vacation and something breaks. You get agents that don’t log to the dashboard, don’t meet governance requirements, don’t fit the responsible AI framework.

We hit all of this. And more.

Seven agents doing roughly the same thing. Nobody quite sure who owned what. A model update quietly breaking something nobody was watching.

Citizen development at scale without operational infrastructure eventually leads to chaos.

Which is exactly what led us to build the Garage.

Creativity without ops is a mess waiting to happen. Ops without creativity is a very well-governed nothing. You need both.

Next: The mess — and what we built to fix it.

Step 5: The Day Anxiety Became Curiosity

📍 Part 5 of 8 · Becoming Agent-Native
An 8-part series on going from delivery team to agent-native organization — lessons earned, not borrowed.
Genesis · Anxiety · Names Matter · Proof of Value · → The Pivot · Co-Creation · The Garage · The Flywheel

There isn’t a single moment. It’s more like a temperature change.

Gradual. And then all at once. Exactly like Hemingway described bankruptcy.

The signal: someone stops asking “is this going to replace me?” and starts asking “what else could they do for me?”

That question – unsolicited, forward-looking, a little excited – is the pivot. And everything after it is different.

What caused it.

Not a single thing. An accumulation.

The email draft that was perfect. The research that came back before they’d finished their coffee. The weekly summary that was just there without anyone asking for it.

When those moments pile up, the mental model flips. The agent stops being a threat and starts being an asset.

And once it’s an asset, a very natural question follows: how do I get a better one?

That question is the whole game. Because it means your delivery team has become an active participant in the quality of their own AI teammates. They want them to improve. They have opinions about how. They’re invested.

The frame that accelerated it.

Our team always has more work than capacity. There are always more customers to serve, more research to run, more value we haven’t gotten to yet.

We are not, and have never been, trying to reduce headcount.

What we’re trying to do is amplify the headcount we have. Get more high-value work. Free people from the repetitive work that agents handle better anyway. Work on the hard stuff. Grow your career.

It’s like the tractor replacing the hand plow. You didn’t lose the farm. The farm got bigger.

When people understood that frame, agents as multipliers, the math became obvious. More impact, same team, better work.

That’s not a threat. That’s a competitive advantage for every person on the team.

What the pivot looked like in practice.

Feedback volume jumped. People who had never commented on an agent suddenly had opinions. Feature requests started flowing. Someone said “could Reese do this if we gave him this additional context?” and “I think George would be even better if he also pulled from this system.”

That’s not tool usage. That’s coaching. And you can’t coach something you’re afraid of.

When you see this shift starting, lean in fast. Turn that spark into a fire. Prioritize the feature requests that come from delivery. Make it visible that their input is landing in the roadmap. Create the fastest possible feedback loop.

The pivot is fragile at first. Feed it.

The moment your team starts coaching their agents instead of tolerating them, the phase change is real.

*Next: What happens when delivery stops requesting agents and starts building them.

Step 4: The Agent Dashboard

📍 Part 4 of 8 · Becoming Agent-Native

An 8-part series on going from delivery team to agent-native organization – lessons earned, not borrowed.
Genesis · Anxiety · Names Matter · → Proof of Value · The Pivot · Co-Creation · The Garage · The Flywheel

Early in Phase 2, before we knew if people would even use these agents, we built a usage dashboard and a small component that every agent had to include – Power Automate, Copilot Studio, M365 Copilot – it was table stakes to onboard.

It felt a bit like overhead at the time.

It became the foundation of everything.

What the dashboard tracked: which agents were being used, how often, by whom, and with what outcome.

Simple. But surprisingly revealing.

Some agents were hits. Usage climbed. Feedback was positive. The team became genuinely dependent on them. These got investment: more features, deeper integration, wider rollout.

Some were mediocre. Usage below expectation but not zero. The dashboard made us ask the right question: is the agent underperforming, or is there an onboarding gap? Is there a better design? Those are different problems. You can’t diagnose without the data.

Some just didn’t work out. And the dashboard gave us permission to retire them. No politics, no ego, just “the numbers say this isn’t earning its place.”

The data showed us insight about people, not just agents.

We saw a clear split emerge: pro users and skeptics.

Some team members were all in. They used agents daily, sending feedback all the time, acting like internal product managers for the agents they’d adopted. Others were lukewarm.

That visibility mattered. It let us find the right internal champions. It let us understand the gap between those two groups. It let us have a business conversation, with real numbers, about what was working.

ROI reporting doesn’t only justify the investment. It shows your team you’re taking this seriously. And them.

But the most important proof never showed up in the dashboard.

It was the moments.

The team member who realized they hadn’t manually changed that case status in weeks. Not because they forgot, but because Theo handled it.

The person who got their Friday afternoon back because George was doing the weekly summary.

The quiet relief of: oh, that’s just handled now.

When those moments accumulate, something shifts. The agent stops being an experiment and starts being infrastructure. The dashboard tracks the what. The moments explain why it matters.

If I were advising someone starting this today, I’d say: Build the measurement layer early, at the business group level, not deep in IT.

Once you have 10 agents and a skeptic asking “what’s the ROI on all this?” you’ll be very glad you have an answer.

“Measure early. The dashboard will make decisions for you that would otherwise become arguments.”

Next: The inflection point, when the team stopped worrying about agents and started wanting more of them.

Part 3: Words Matter, This Is Not a Branding Exercise

📍 Part 3 of 8 · Becoming Agent-Native

An 8-part series on going from delivery team to agent-native organization – lessons earned, not borrowed.
Genesis · Anxiety · → Names Matter · Proof of Value · The Pivot · Co-Creation · The Garage · The Flywheel

I wrote about this in August Agents: Names Matter and it was the right instinct. Now, on the other side of the full journey, I understand why it worked even better than I thought at the time.

Reese. Casey. Nabha. Elliot. Gibbs. Mona. George. Winston. Axel. Lily.

These aren’t product names. They’re teammates.

That distinction (which can sound like fluff the first time you hear it) turned out to be one of the most operationally significant decisions we made.

Here’s the simple version of why it works.

When something is a tool, your relationship to it is passive. You use it or you don’t. You don’t give a shovel feedback. You don’t coach a dashboard. Tools sit in a drawer until someone reaches for them.

With a teammate, your relationship is active.

You onboard them. You give them context. You tell them when they’re missing the mark. You notice when they improve. You advocate for them when someone else doesn’t understand what they do.

When your team has a stake in an agent’s success, they do something invaluable: they give feedback. Quality feedback. The kind that makes agents genuinely better.

We did regular performance reviews with our agents. More frequent right after onboarding or a new capability release (just like a new hire or after a promotion), less frequent as they found their footing. Same discipline as the rest of the team.

George is the clearest example.

Before George, Friday afternoon meant pulling together the week’s work, surfacing the key insights, formatting it, and getting it to the right people. Valuable. Tedious. The first thing that got cut when Friday got busy.

George does it automatically. He looks across everything you have produced, finds the biggest insights, and delivers them without anyone asking.

But here’s what made George good: feedback. Lots of it. Specific feedback from people who saw George as a teammate they were invested in making better.

That feedback loop exists in part because of the naming. Because of the personification. Because of the decision to onboard rather than launch.

There’s a governance benefit too, which we didn’t anticipate.

Naming forces clarity. When Mona graduated from a personal helper to a team-level role, we treated it like a promotion. Clarified scope. Assigned an owner. Eliminated overlap with other agents who’d been doing adjacent things.

Without that discipline, you get what I’ll describe in Part 6: seven agents doing roughly the same thing, disjoint responsibility, things slowly breaking.

Personas force you to think like an org designer, not just a builder. And be very clear, you are building an org.

The question your team will stop asking once agents have names:

“Do we need this?”

The question they’ll start asking:

“How do we help them thrive?”

That’s a completely different organization.

Giving your agents personas isn’t just adoption strategy. It’s how you build a team that includes humans and agents and actually functions like one.

Next: How we knew any of this was working — and what happened when we looked at the data.

Part 2: The Thing Nobody Warns You About

Part 2 of 8 · Becoming Agent-Native

An 8-part series on going from delivery team to agent-native organization — lessons earned, not borrowed.
Genesis · → Anxiety · Names Matter · Proof of Value · The Pivot · Co-Creation · The Garage · The Flywheel

Most AI transformation stories skip Phase 2.

They go from “we built some agents” straight to “adoption soared and everyone loved it.”

That’s not what happened for us.

When we introduced the first agents to the delivery team, the reaction wasn’t excitement. It wasn’t curiosity.

It was anxiety. Real anxiety. The kind that doesn’t announce itself clearly. It comes out as skepticism, low usage, polite questions with an edge underneath them.

The edge was: is this going to replace me?

Nobody said it that way. But it was in the room.

There was a second layer too. A small squad had gone off and built things, and now those things were showing up in workflows that had been their workflows. It kind of felt like change being done to them.

“I feel like I’m on the outside looking in at my own job being replaced.”

That’s not a technology problem. That’s a trust problem. Technology solutions don’t fix trust problems.

We made two structural choices. Both matter.

The first choice: we doubled down on agents being teammates, not tools; we gave them all personas and personalities.

This sounds like semantics. It isn’t.

A tool is something you use, or don’t. It sits there. It doesn’t get better. It doesn’t respond to coaching. It doesn’t care if it’s valuable or not.

A teammate is different. A teammate can be given feedback that actually changes how they work. You can advocate for them. You can push for them to be more capable. You have a stake in whether they succeed.

When people have a stake in something, they engage with it differently.

The second choice: every agent got a name.

Reese. Casey. Theo. Mona. George.

Not product names. Not “AI Assistant v2.3.” Real names, each one tied to the function, each one introduced the way you’d introduce a new hire; with context, with expectations, with a clear path to give feedback.

More on this in the next post, but the short version: named agents get coached. Unnamed tools stay static and get ignored. When was the last time your garden rake got an upgrade?

The anxiety didn’t disappear overnight. But it had somewhere to go.

The question shifted from “is this replacing me?” to “how do I best work with this?”

That’s the crack in the door. That’s what Phase 3 is about.

You can build the best agent in the world. If your team doesn’t trust it, you’ve built nothing of value.

Next: Why naming your agents isn’t branding; it’s adoption strategy.

Part 1: Becoming Agent Native.

📍 Post 1 of 8 · Becoming Agent-Native

An 8-part series on going from delivery team to agent-native organization – lessons earned, not borrowed.
→ Genesis · Anxiety · Names Matter · Proof of Value · The Pivot · Co-Creation · The Garage · The Flywheel

We Started in Our Worst Quarter. On Purpose. Q4. Our busiest quarter. The one where we’re all running flat out and nobody has margin for anything extra.

That’s when we decided to pull a small group off delivery and dedicate them to building AI agents.

People thought we were crazy. The timing was bad. But here’s the thing about timing: there’s never a good quarter to change how you work. If you wait for a slow moment, you’re waiting forever.

Three decisions made Phase 1 work. They’re worth naming clearly, because we got all three right (and had gotten them all wrong in an earlier attempt).

Decision 1: Delivery resources. Not new headcount.

The instinct is to hire specialists. Build a separate AI team. Find people with “AI” in their title.

We did the opposite.

We took people already doing the work – people who knew exactly where the friction was, who understood what “a bad Monday looks like” in our workflow – and we gave them dedicated time. Not 10% time. Not a side project. A real squad with a real mandate.

The people who know the pain are the ones motivated to build the cure.

Decision 2: Low-code or nothing.

We made it a mandate: no code-based solutions. No Foundry builds. No MCP servers. No deep engineering.

Partly practical; code means maintenance, and we didn’t have a team to own that. But mostly strategic. The platforms were moving faster than we ever could. Our edge wasn’t engineering. It was application. Low-code kept us in our lane.

Decision 3: Start embarrassingly small.

We had tried the big project approach before. A large-scale agent initiative run as a hobby by people with other jobs to do.

It failed. Not because the vision was wrong. Because nobody owned it, nobody had real time for it, and the scope was too big to make rapid, visible progress.

This time: small agents. Single tasks. The thing you do six times a day that shouldn’t require a human.

Not a meta-agent. Not a platform. Just: let’s automate that one thing that people hate doing.

Out of Phase 1, we had a handful of agents doing small, specific, daily automations. Unimpressive on a slide. Genuinely useful in a workday.

That was enough to move to Phase 2.

The biggest barrier to starting isn’t technology or budget. It’s the belief that you need a huge, perfect project to justify the investment. You don’t.

Next: What happened when those agents met the broader delivery team, and why it didn’t go the way we expected.

Remember the TCP/IP Stack Wars?

Same Frenzy, New Plumbing

In the early 1990s, “networking” on a PC was a jigsaw puzzle. You didn’t have TCP/IP. You assembled TCP/IP:

The right stack
The right network card
The right driver
The right OS version
The right configuration (that you’d only discover was wrong at 2am)

If you’re too young to remember this, imagine that the new thing for your work PC was to connect others send messages…but email only worked inside your company, and was not connected to the internet. You carried a briefcase full of papers home if you needed to work on something after hours. You probably didn’t have a mobile phone, and if you did it was mounted in your car – and only made voice calls.

I worked in customer support at a company that lived at the intersection of hardware, software, and networking. Our application ran across multiple protocols, so we didn’t just watch customers struggle—we helped them fight the puzzle: stack + driver + NIC + OS + application. It wasn’t just technical complexity. It was market immaturity.

This is the LLM market today.

Act I: Monetize the Mess

Inside the company I worked for, leadership was on a path to buy a TCP/IP stack to provide a consistent foundation for our applications.

The absurd part: application teams had to make functionality decisions based on disparate network stacks. Test teams had to test them all. Users had to understand them to get them to work. Then someone kicked the cable out of the adapter under their desk and the whole network went down.

Have you tried Hummingbird and Chameleon on both EtherLink and NE2000? What about when the network has both BNC and 10-BaseT connectors?

Networking vendors made tons of money in the confusion…and the switching costs…and the new versions. I believed the stack (and maybe the network cards) were heading toward commodity status. Essential, but not differentiating. I argued against buying or building a stack.

Act II: Standardize It (the Part Everyone Forgets)

TCP/IP didn’t win because one vendor’s stack was the best. Ethernet was technically deficient to Token Ring. But they both won because they became the standard—and standards create gravity. Once the interfaces stabilized, the application didn’t care whose stack you bought.

That’s the key idea: the application shouldn’t care. The user shouldn’t care. Maybe the IT department cares for a while, but eventually just procurement cares.

Act III: Forget It’s There

Once TCP/IP became “default” and the interfaces stabilized, the market stopped paying premiums for stacks.

Networking wasn’t eliminated. Thinking about networking was eliminated. Who knows which network adapter is in their new laptop today? Can you imagine buying a laptop without connectivity? It’s unthinkable.

History continues to prove the pattern:

Monetize → Standardize → Forget

The LLM World Is in Its “Stack Wars” Era

Today’s LLM discourse sounds like the early 90s networking discourse—just with better fonts and worse certainty:

Which model for which task?
Which provider is “best”?
Should we build our own?
How do we avoid lock-in?

It’s the same jigsaw puzzle, modernized:

model + prompt style + tooling + memory + safety + cost + latency

And it produces the same executive temptation:

“Let’s build the stack so we control our destiny. Everyone is doing it; we don’t want to be left behind!”

The value today, in the complexity phase, is the model. The value in the future is the thing that uses those models.

Segmentation: Specialized Providers vs Specialized “Application-Layer Engines”

Yes—there are real segments emerging: coding, personal info management, health, and more.

But the more important question is where specialization will live:

Path A: Specialized model providers dominate each segment

“Best model for coding.” “Best model for health.” “Best model for XYZ.”

Path B: Commodity base models + specialized implementations on top

Fine-tunes, adapters, retrieval, tool-use, memory, evals—packaged as product capabilities. In applications.

Path B is the historical match.

The winning move is applications standardize how they connect to intelligence, and the model selection becomes invisible plumbing.

That’s the interoperability point—and it’s where network effects quietly return.

Network Effects: TCP/IP Interoperated with Networks. LLMs Interoperate with Tools.

TCP/IP’s network effect was obvious: the value came from being able to talk to other networks.

LLMs don’t inherently need to “talk” to other LLMs. They compete on capability.

So where’s the network effect?

It moves up one layer.

That’s why protocols like Model Context Protocol (MCP) matter: they standardize how AI systems connect so developers don’t rebuild bespoke, model specific integrations.

Once connectivity is ubiquitous, the LLMs start to disappear.

Phase 1: Value = Plumbing
         (TCP/IP stacks | LLM providers)

Phase 2: Value = Interfaces
         (Winsock | MCP)

Phase 3: Value = Outcomes
         (Connectivity | Apps & Agents)

The Pattern Is Undefeated

Every platform shift starts the same way:

We monetize the complexity.
Then we standardize the plumbing.
Then we forget it was ever hard.

TCP/IP stacks were once a market category. Now they’re invisible.

LLMs are in their stack-wars era.

The winners won’t be the companies with the prettiest model demo…or even the best model. They’ll be the ones who make magical apps and let you forget the model exists.