The Coulson Protocol
An illustrated story of AI, human judgment, and what happens after the handoff

Chapter 1 — The Human Bottleneck
Something was changing across our Engineering teams at Kissflow.
We had built AI agents to help our Engineers investigate issues. That work had once been slow and manual. The agents could gather facts, look for causes and suggest the next action.
Two of them were already doing this work.
Invoker, created by Sricanth, helped with issues on our 4.0 Product Issues board. It read the details, looked for clues and worked out what it needed from people.
FRIDAY, created by Aravindhan, worked with Team DevOps & SRE on our AOS board. It studied live issues, sorted them and helped find the next action.
They handled different problems but followed the same idea. Let AI do the research it can. Bring people in when their knowledge, decisions or actions are needed.
That was how we wanted Human + AI Engineering to work.
And the agents were doing their part.
But something wasn't working as expected.
Imagine Invoker has looked into an issue. It has read the details and found a question for an Engineer.
Invoker tagged the person who could answer it.
Then it waited.
On another board, FRIDAY might finish its research and ask someone to check a finding or act.
It waited too.
Sometimes people answered, and the work moved on. Other times, no answer came.
The agents had done their part. They had studied the issue, found what was missing and asked the right people.
Yet the issues remained open.
I began noticing this pattern while reviewing work across the boards.
At first, it looked like a common problem. Every Engineering team has work waiting for reviews, decisions or updates.
But this situation bothered me for a different reason.
We had helped AI agents study issues faster and in more depth. They spent less time finding the problem and the next action.
Why, then, were some issues still waiting after that action had already been identified?
I wanted to know what happened between the agent's findings and a person's reply.
So I started examining the history of these cards more closely, with JARVIS already assisting me.
I didn't just check whether a card was open or closed. I read the messages and looked at what people had done.
Who had been asked to do something? Was the question clear? Had the person responded? If they had, did the response actually help move the work forward?
The distinction mattered.
An Engineer might reply without finishing a review. Someone might say a fix was ready, though the related code change still needed approval. Another person might post an update but leave the key question unanswered.
A card could have plenty of activity and still make little progress.
The more I examined these situations, the clearer the gap became.
Our agents could study issues and find the next action. But they couldn't make sure the person being asked would act.
When that handoff failed, the work could stay stuck despite all the agent had done.
We had made AI research stronger. But the handoff to people was still weak.
That was the problem I wanted to solve.
I didn't want more reminders. I wanted to ask the right question, reach the right person and help the work move.
JARVIS was already part of that effort, but I was still doing much of the piloting myself.
Before handing over more of the work, I had to teach JARVIS my method. How did I read a card? What proof did I look for? When was a follow-up worth sending?
That became our next experiment.
Chapter 2 — Teaching JARVIS to Follow Through
JARVIS had been with me from the beginning of this follow-up experiment.
But there was a difference between having an AI assistant and trusting it to handle an investigation properly.
In the early days, I was still the pilot.
JARVIS helped me gather information, examine cards and prepare notes. I worked closely with it, checking its findings and guiding it through the questions I would normally ask myself.
It had access to tools that could help us investigate. What mattered was teaching it how to use those tools, connect the evidence and reach a sound conclusion.
A card's latest comment was only one part of the story.
Suppose someone had written that a fix was ready. Before following up, we needed to understand what ready meant.
Had the change been tested? Was the pull request merged? Had the fix reached production? Or was someone still waiting for a review?
The answers could be found in different places.
Sometimes we needed the card's history. Sometimes we needed logs, engineering activity or the state of a pull request. Sometimes a conversation elsewhere had already changed the situation.
I wanted JARVIS to investigate before drawing conclusions.
So I guided it through the process.
We would begin with the original issue, read what had happened since, examine the evidence and identify what was still missing.
If something didn't add up, we would investigate further.
Only then would we decide whether someone needed a follow-up.
And even then, the wording mattered.
A message saying Any update? might be easy to write, but it often left the recipient to figure out what we wanted.
A useful follow-up needed to show that we understood the situation.
If a review was pending, ask about the review. If a decision was missing, identify the decision. If someone had already completed their part, recognize that and find out what remained.
The purpose wasn't to get a reply for the sake of getting one.
It was to help the next action happen.
As we worked through more cards, I corrected JARVIS whenever its analysis was incomplete or its proposed question missed the point.
Gradually, we developed a more reliable method.
Read the history. Research the issue. Verify the findings. Understand the remaining gap. Prepare a follow-up that addresses that gap.
And never assume that a confident-sounding update is the same as verified progress.
With practice and refinement, JARVIS began taking on more of the work.
Instead of guiding every investigation myself, I could have it examine several cards, gather the supporting evidence and prepare the follow-ups for my review.
My role began to shift.
I was spending less time gathering the information and more time evaluating what JARVIS had found.
But I wasn't handing it unrestricted authority.
Every outgoing note still needed my approval. JARVIS would show me the draft, and I could approve it, change it or decide not to send anything.
Once I approved the exact message, JARVIS could post it and check that it had appeared on the card.
This was an important part of how our Human + AI approach was evolving.
JARVIS could do more of the investigation and execution. I remained responsible for the judgment.
Meanwhile, someone else was examining our work from another angle.
Sankaran.
Sankaran was already working on Invoker. He also began auditing the follow-ups I was sending with JARVIS.
He wasn't simply checking whether the messages were correct.
He wanted to know whether they were useful.
Did a follow-up introduce information that mattered? Did it identify a real next action? Or was it repeating an earlier question without adding anything?
His reviews gave us another way to examine the process.
Some notes were useful as written. Others needed improvement. A few were little more than reminders that had come too soon or continued too long.
Those findings mattered because they challenged an assumption we could easily have made: that a well-researched follow-up must also be a good follow-up.
It wasn't always true.
The question needed to be relevant, timely and capable of helping someone act.
We used those observations to refine how JARVIS worked.
The research became more structured. The questions became more deliberate. And the approval process helped keep the final judgment with me.
The experiment was progressing.
But as JARVIS took on more of the piloting, I noticed another problem.
Almost every routine follow-up still passed through my desk.
JARVIS could examine a card, find an unanswered question and prepare a useful message. But I still had to review and approve that message before it went out.
And the responsibility for making sure those follow-ups happened remained largely with me.
We had made JARVIS more capable, but we hadn't yet made the process independent of the Director.
That was a problem worth solving.
Because if our goal was to help Team Engineering work with greater ownership and independence, the follow-up process couldn't continue to depend on one person.
The people closest to the work needed to own what happened next.
JARVIS had helped me build and refine the method.
Now it was time to find a way for the team to carry it forward.
And that brought Team Viberanium Squad into the story.
Chapter 3 — The Birth of Coulson
JARVIS had learned to investigate cards, examine the evidence and prepare follow-ups that asked meaningful questions.
But one problem remained.
Almost every follow-up still passed through me.
That wasn't the future I wanted for Team Engineering.
If we were building AI agents to help our teams become more capable and independent, the process couldn't depend on the Director to keep it moving.
The people closest to the work needed to own what happened next.
And I already had a team working on a much bigger challenge.
Team Viberanium Squad.
The name combined Vibranium from the Marvel universe with Vibe Engineering, our approach to building software with AI.
The Squad had a mission much bigger than building individual AI agents.
Team Viberanium Squad's mission is to mature Platform Engineering practices by using the Product Development Life Cycle (PDLC) to set up and operate AI Product Factories at scale.
Platform Engineering gives teams a foundation to build, release and operate products without solving the same problems again and again. The PDLC takes a product from an idea through design, development, deployment, operation and continuous improvement. An AI Product Factory is where teams build and run AI-powered products repeatedly and at scale.
Coulson was one of the experiments helping us work toward it.
Three people were central to this part of the story.
Sricanth led the Squad. He had created Invoker, the agent investigating issues on the 4.0 Product Issues board. The team was also preparing to take Invoker further, and it would later be renamed Vision.
Sankaran was working on taking Invoker to scale. He knew our follow-up process from another angle too. He had been auditing the notes JARVIS and I produced, looking for questions that helped the work move forward and those that merely repeated earlier requests.
Gayathri was taking FRIDAY to scale, building on the work of its creator, Aravindhan. She understood the operational challenges on the AOS board, where one issue could involve an Engineer, a reviewer, a verification step and several decisions before it could be closed.
Each brought a different perspective.
And that mattered because the problem wasn't simply about writing better reminders.
It was about helping people follow through without creating another layer of dependency.
On 26 October 2026, I handed the problem to the Squad.
The idea was to move routine follow-ups away from my desk and into the hands of the team.
Sankaran would take the 4.0 Product Issues lane. Gayathri would take AOS. They would cover for each other when needed, with Sricanth handling the first escalation.
I would remain available when something genuinely needed my involvement.
But routine follow-ups should no longer wait for me.
There was one principle I wanted to carry forward from the JARVIS experiment.
AI could prepare the follow-up. A human would own the decision to send it.
The person responsible would review the message, approve the exact wording and have it posted under their own identity.
We weren't trying to replace human ownership with a bot account. We were trying to make ownership easier to exercise.
The original plan was to extend Invoker and FRIDAY with the follow-up method JARVIS and I had developed.
Both agents already worked with their respective boards. It seemed natural to build on them.
But I hadn't handed the Squad a design that they were required to follow.
I wanted them to examine the problem and challenge the approach if they found a better one.
And they did.
That evening, Sricanth shared a workflow for the 4.0 Product Issues board.
It described how the system could examine a card, find an unanswered request and determine when the next follow-up should happen.
If the request remained unanswered, another Squad member could take the next step.
There was a name at the top of the workflow.
Coulson.
It fitted our Marvel-inspired world. The records don't establish who chose the name, so that part of its origin remains untold.
What we do know is that the idea had already moved beyond the original proposal.
Sankaran had started building Coulson as a separate Claude Code plugin.
Invoker and FRIDAY would continue doing what they were designed to do: investigate issues and help identify the next action.
Coulson would focus on the part that followed.
Once a person had been asked to act, Coulson would examine the card's history, identify whether a response was still due and prepare the appropriate follow-up.
But how would it know when to follow up again?
The follow-up ladder
The Squad designed a sequence of steps so an unanswered request wouldn't quietly disappear.
On the 4.0 Product Issues board, Sankaran would handle the first follow-up. If the request remained unanswered after the next waiting period, Gayathri would take the second. Sricanth would handle the third.
AOS followed a similar sequence, but Gayathri would go first, followed by Sankaran and then Sricanth. If a fourth AOS follow-up was needed, Sricanth would own that too.
The ladder followed working-day rules, not ordinary calendar days. Coulson examined the card's history to work out when a request had been made, whether the person had responded and whether the next follow-up was due.
The steps were check-ins, not automatic deadlines or penalties.
And each step still required the responsible person's approval before a message could be posted.
On certain 4.0 cards waiting for information from the requester, the final step could close the card, but only after human approval. Coulson never closed AOS cards.
There was another challenge.
The Squad wasn't running Coulson from one shared computer. Each member would use it from their own laptop.
So how would Coulson know what another person had already done?
The Squad would need a shared record that each laptop could read. Otherwise, one person might send a follow-up while another person's copy of Coulson continued waiting or started the sequence again.
How to make that work reliably was still a problem to solve. And the first real code review would expose exactly why.
Figure 1 — Every step has a named owner.
When the design met reality
A useful follow-up system needed to handle the ordinary complications of Engineering work.
What if someone replied after Coulson prepared a draft but before the human approved it?
What if the person responsible for a follow-up was on leave?
What if Coulson misunderstood a comment and prepared a message that wasn't needed?
These weren't unusual situations. They were the kinds of things that happen every day.
Sankaran worked through the design and began building the system around those needs.
Gayathri brought in the rules for AOS. An operational issue didn't always behave like a product issue. A new comment, a verification request or a change in status could mean different things depending on the card's history.
Sricanth continued shaping the workflow and reviewing the implementation.
I stayed involved in challenging the design, especially where it risked bringing routine ownership back to me.
One question exposed that risk clearly.
The early AOS design placed the fourth follow-up with the Director.
But if every difficult follow-up eventually returned to my desk, what had we really changed?
We would have distributed the first few steps while leaving the final routine dependency exactly where it had been.
So the design changed.
Sricanth took responsibility for the fourth AOS follow-up as well.
I remained available for exceptional escalations, but the routine follow-up sequence belonged to the Squad.
That distinction was important.
We weren't building Coulson so I could manage a larger number of follow-ups.
We were building it so the team could own the follow-through.
Within the first days, the Squad had moved from a handover brief to a working design and an implementation taking shape.
Sankaran was creating Coulson. Sricanth was helping shape its workflow and escalation model. Gayathri was bringing the realities of AOS into the design.
But a system that looks right on a diagram still has to survive real work.
And real work rarely follows a perfect sequence.
Someone posts from another laptop. A card changes while a message is being reviewed. An update is mistaken for a follow-up. A request that looks unanswered has already been handled elsewhere.
Coulson would have to learn to deal with all of that.
The next challenge wasn't simply making it send the right message.
It was making sure it knew when not to send one.
Chapter 4 — When Coulson Met the Real World
Building Coulson wasn't just about getting an AI assistant to write a useful follow-up.
JARVIS and I had already spent time learning how difficult that could be.
The Squad faced a different challenge.
Coulson needed to work across two boards, three people and three laptops. It had to understand what had already happened, identify what was still waiting and prepare the next message without creating confusion.
And it had to do all of that while keeping the final decision with a human.
Sankaran began building the system around those requirements.
The first version could examine a card's history and determine whether a follow-up was due. It could identify who should send the message and prepare a draft for that person to review.
On paper, the approach was straightforward.
But the first serious problem appeared before Coulson had even completed its initial rollout.
The problem between two laptops
On 27 October, Gayathri was reviewing the implementation.
She found something that could cause follow-ups on the AOS board to stop unexpectedly.
Imagine Gayathri sends the first follow-up on an issue. The person responsible doesn't answer, so the next follow-up should eventually come from Sankaran.
But Sankaran is running Coulson on his own laptop.
How does his copy know that Gayathri has already sent the first message?
The initial implementation had a problem here.
When Coulson examined the card, it could treat Gayathri's follow-up as ordinary activity. Instead of recognizing that the first step was complete and the next step should be scheduled, it could restart its waiting period.
The follow-up sequence could stall.
Nothing needed to crash. No error message had to appear.
The system could simply keep waiting when it should have moved to the next step.
Gayathri caught the problem during code review.
Sankaran corrected the logic that same day.
Coulson needed a reliable way to recognize its own follow-ups, regardless of which laptop had sent them.
The solution was to use the card itself as the shared record.
Each Coulson follow-up would carry a hidden marker identifying its step. When another Squad member examined the card, Coulson could recognize what had already happened and determine the next action.
The drafts and working files could remain on each person's laptop. The important shared history would remain with the work item.
It was a small technical detail with a large consequence.
Three people could now follow the same work without relying on one laptop to remember everything.
But recognizing earlier follow-ups was only part of the problem.
Coulson also had to understand which comments were follow-ups in the first place.
And that would prove more difficult.
A message that wasn't a follow-up
By the end of October, Coulson had started moving beyond design and testing.
On 29 October, Sankaran's laptop posted the first four follow-ups on the 4.0 Product Issues board.
Each message went through individual human approval.
There was no single button to approve every message at once.
That was deliberate.
A follow-up could affect a real person's work. It might ask for a decision, question an earlier update or bring someone else into the conversation.
We wanted the person sending it to remain responsible for what it said.
The system was taking shape, but the early runs were still exposing problems.
On 2 November, Gayathri encountered one of them.
A 4.0 Product Issues card contained an earlier analysis note from a Squad member.
Coulson interpreted that note as if it were the first follow-up in its sequence.
That changed its understanding of the card.
Instead of preparing the first follow-up, it moved ahead to the second.
The system had confused two different actions.
Someone analyzing a problem isn't necessarily following up with the person responsible for the next step.
The distinction might seem obvious to a human reading the conversation.
But Coulson had to learn it through its rules and checks.
Gayathri recognized that the proposed step was wrong.
She skipped the draft. Nothing was posted.
That was exactly why the human approval gate mattered.
Coulson had made a mistake, but the mistake didn't have to become a message sent to another person.
The problem was then corrected so the system could better distinguish an analysis note from an actual follow-up.
This wasn't simply a case of finding a bug and fixing it.
It showed us something important about the kind of system we were building.
The human who could say no
When people talk about AI automation, much of the attention goes to what the AI can accomplish without assistance.
How much can it investigate?
How quickly can it prepare an answer?
How many actions can it complete?
Those questions matter.
But Gayathri's decision brought another question into focus.
What happens when the AI is wrong?
Coulson could prepare a message, but that didn't make the message correct.
It could calculate that a follow-up was due, but its calculation depended on how accurately it understood the card.
It could identify the next person in the sequence, but that didn't mean the next message was appropriate.
The human reviewing the draft needed the authority to challenge it.
And that authority had to be real.
Coulson's approval process offered three choices: approve the message, edit it or skip it.
Before an approved message was posted, Coulson would read the card again. If the card had changed since the draft was prepared, it would stop rather than send an outdated message.
After posting, it would read the card back to verify that the message had appeared.
There was no approve-all shortcut.
These safeguards didn't guarantee that every message would be correct.
But they made it possible to catch errors before those errors reached other people.
Gayathri's decision on 2 November demonstrated the value of that design.
She wasn't there merely to approve what Coulson suggested.
She was there to exercise judgment.
And in that instance, the right judgment was not to send anything.
That was the Human in HumAI we wanted to preserve.
When two copilots follow up
There was another complication.
Coulson wasn't the only assistant examining these boards.
JARVIS was still helping me investigate issues and prepare follow-ups.
That meant the same work item could appear in two different workflows.
Coulson might identify an unanswered request and prepare a follow-up for the Squad.
JARVIS might examine the same card and prepare another message for me.
Both could be acting on legitimate information.
But if we weren't careful, the person responsible for the work could receive two follow-ups about the same question.
That wouldn't improve ownership.
It would create noise.
So we needed a clear boundary.
When Coulson had taken responsibility for a routine follow-up, JARVIS should not chase the same request.
JARVIS could still help with matters that needed a different kind of judgment, such as a genuine escalation or a separate decision.
But routine follow-through belonged to the Squad.
The team worked on checks to identify overlapping messages. Those checks also revealed gaps that needed correction.
A message could appear harmless while still chasing someone Coulson was already waiting on. A change in the card's status could alter who owed the next action. Even a small difference in how a person's name was written could affect a check.
The system had to become more careful about these details.
And so did we.
I continued reviewing JARVIS's activity against Coulson's work, looking for duplicate follow-ups, missed steps and incorrect assumptions.
Sometimes those checks uncovered problems in Coulson.
Sometimes they exposed mistakes in JARVIS's interpretation.
I had to correct my own conclusions too.
The handover hadn't removed human judgment from the process.
It had changed where that judgment was needed.
The difference between a working tool and a reliable one
By early November, Coulson was being used on real work items.
The Squad had moved beyond discussing how follow-ups should happen. It was testing the approach against actual card histories, real requests and changing Engineering work.
The early results were mixed.
Some follow-ups went out as intended.
Others were skipped because they weren't appropriate.
There were false alarms, missed steps and cases where the system needed more context than the card contained.
Those weren't reasons to abandon the experiment.
They were reasons to keep examining how it behaved.
A reliable system couldn't be judged only by whether it produced a message.
We needed to know whether the message was due, whether it asked the right person, whether it reflected the latest information and whether it helped the next action become clearer.
And we needed to know when the system had failed to act.
Coulson was still evolving. It wasn't yet a fully hosted service running independently of the Squad's laptops.
The people operating it were still part of its reliability.
That was the reality of the experiment.
We had started with a problem in which AI agents could investigate an issue, but the next human action could remain unanswered.
Now we were building an assistant to support that missing follow-through.
Yet Coulson was teaching us that a follow-up could fail in more than one way.
It could arrive too late.
It could go to the wrong person.
It could repeat a question that had already been answered.
Or it could be technically valid while missing something important that happened outside the card.
That last problem would lead to another discovery.
Sometimes the work had moved forward. Coulson simply couldn't see it.
Chapter 5 — The Conversation Coulson Couldn't See
Coulson was learning to follow the history of a work item.
It could read the questions people had asked, recognize earlier follow-ups and identify who still owed an answer.
But there was something it couldn't see.
A conversation that happened somewhere else.
That might not sound like a serious problem. After all, our Engineers communicate in many ways. They discuss issues in Google Chat, speak during calls and sometimes settle questions through direct messages.
Those conversations are part of everyday work.
But they aren't always reflected on the card where the work is being tracked.
And for Coulson, that difference mattered.
An answer that was already given
On 2 November, Coulson was following up on an AOS issue involving a database capacity plan.
The work had reached a point where someone needed to approve a draft email before the next action could proceed.
When Coulson examined the card, it found an unanswered request for that approval.
So it prepared a follow-up.
Gayathri reviewed and sent the message under her own identity, asking the person concerned to validate the draft.
There was just one problem.
The approval had already happened.
It had been given in a separate Google Chat conversation.
But the AOS card hadn't been updated to reflect that decision.
From Coulson's point of view, the request was still unanswered.
From the team's point of view, that particular decision had already been made.
Neither view told the whole story.
The approval existed, but the place where Coulson looked for it was out of date.
When I examined the situation, I wanted to understand why the decision hadn't been recorded on the card.
The person responsible acknowledged the gap and updated the work item with the current state.
That helped clarify what was actually waiting.
But it also exposed a limitation in our design.
Coulson could examine the card carefully and still reach the wrong conclusion if the card didn't contain the latest information.
Its research was only as complete as the information available to it.
Should Coulson read Google Chat too?
The incident raised an obvious question.
If important decisions were happening in Google Chat, should Coulson read those conversations as well?
At first, that seemed like a natural extension.
Give Coulson access to more information, and perhaps it could make better decisions.
But the problem was bigger than giving an agent another tool.
Imagine a work item being discussed in several places.
An Engineer posts an update on the card. Another person asks a question in a group conversation. A decision is made during a call. Someone confirms it privately.
Which version of the work should Coulson trust?
And what happens when those conversations disagree?
The more places an agent has to examine, the harder it becomes to establish a clear and reliable picture of the work.
We could keep expanding Coulson's reach.
Or we could improve the way we recorded decisions.
The second approach began to make more sense.
The card should carry the current state of the work.
That didn't mean every conversation had to happen on the card.
People could continue discussing problems wherever it made sense.
But when a conversation produced an important decision, action or change in ownership, that outcome needed to be recorded where the work was tracked.
A short update could be enough.
Who made the decision?
What was decided?
What happens next?
Who owns that next action?
This would help Coulson, but it would also help the humans working on the issue.
Someone joining the conversation later wouldn't have to search through several Chat threads to discover what had already been agreed.
The information would travel with the work.
It was an emerging operating principle, not a rule we could claim everyone had already adopted.
And another AOS issue showed why it mattered.
When a fix isn't finished
On 27 October, Team DevOps & SRE had been working on a problem affecting background functions in a QA environment.
A network policy was blocking the functions from running.
The cause was identified, and the configuration was corrected.
QA tested the change.
The test succeeded.
FRIDAY also recorded the verification result.
At that point, someone reading only the successful test might reasonably think the issue was finished.
But it wasn't.
The related pull requests still needed to be merged.
The card was reopened.
Over the following days, updates appeared saying the work would be closed that day.
Yet the required reviews were still pending.
This was the kind of situation that had concerned me during the original JARVIS experiment.
A statement could be true in one sense and incomplete in another.
The fix had worked during testing.
But the work required to complete the change hadn't finished.
Those were two different things.
Gayathri examined the actual pull request status rather than relying only on the latest comment.
She followed up on what was still pending.
Later, when the discussion pointed to an update in the team's group chat, she asked for the current status to be recorded on the AOS card.
The goal wasn't to duplicate the conversation.
It was to make the next action visible to everyone who needed it.
As of our research review, the card remained open, with the pull requests still awaiting review.
Coulson hadn't magically resolved the issue.
Neither had the follow-ups.
But the case illustrated why a reliable follow-up process needed to distinguish between activity, partial progress and completed work.
A reply isn't always progress
This was a lesson I had been working through even before Coulson existed.
An acknowledgment wasn't necessarily an answer.
An answer wasn't necessarily a decision.
And a decision wasn't necessarily an action.
Consider the difference between two updates, such as:
Will check.
And:
The change has been tested successfully. Two pull requests are still waiting for review.
Both are replies.
But the second gives the team a clearer understanding of what has happened and what remains.
It tells us where to look next.
That was the standard we wanted our follow-ups to support.
There was an important limitation, though.
Coulson wasn't independently judging whether every human response represented meaningful progress.
Its follow-up logic could recognize a response from the person being asked and stop that particular waiting sequence.
Determining whether the response was sufficient still required human judgment.
We hadn't solved that challenge simply by building another agent.
Instead, we were learning where the agent could help and where people still needed to examine the outcome.
That distinction was becoming central to the Coulson experiment.
Making the work easier to follow
The two AOS issues were different.
In one, a decision had already been made but wasn't visible on the card.
In the other, a fix had passed testing, but the remaining work was still incomplete.
Yet both pointed to the same problem.
The visible activity didn't always tell us the true state of the work.
Coulson could help identify unanswered requests.
JARVIS could investigate further when needed.
FRIDAY and Invoker could continue helping Engineers diagnose and work through issues.
But none of those capabilities removed the need for people to keep the work record accurate.
If a decision happened elsewhere, someone needed to bring that decision back to the card.
If a fix was only partly complete, the remaining action needed to be clear.
And if a follow-up revealed new information, the people involved needed to use it to decide what happened next.
The experiment was beginning to teach us something beyond how to build a follow-up assistant.
A reliable AI workflow depends not only on what the agent can do, but also on how people maintain the information and decisions around it.
That was especially important for Team Viberanium Squad's larger mission.
If we wanted to build and operate AI-powered products at scale, we needed systems that people could understand, verify and trust.
Coulson was one small experiment in that direction.
And it was still teaching us.
We had learned how to recognize follow-ups across laptops.
We had seen why a human needed the authority to stop an incorrect message.
Now we were learning that the work item itself needed to tell a complete enough story for the next person—or agent—to continue.
But one question remained.
How would we know whether Coulson was actually making follow-through better?
Sending a message was easy to count.
Proving that the message helped the work move forward was something else entirely.
Chapter 6 — Measuring What Matters
Coulson was no longer just a name on Sricanth's workflow diagram.
Sankaran had built the first version. Gayathri had helped shape how it handled AOS work. The Squad was now using it on real cards. Each person reviewed and approved the messages sent under their name.
That was a milestone. But did it mean the work was moving?
We had begun this journey because Invoker and FRIDAY could investigate issues and identify the next human action, yet the work could still stall. Coulson was built to support that missing follow-through.
So I wanted to know more than how many notes it had sent. I wanted to know what happened after those notes reached people.
The first report
On 2 November, Sankaran shared Coulson's first report. It covered the early live runs.
On the 4.0 Product Issues board, Coulson had sent eleven notes across nine cards. On AOS, it had sent two notes on one card.
Only six notes were old enough for the report to check whether anyone had replied. Three had received replies. Three had not.
Figure 2 — A reply isn't always progress.
It was a useful start, but the sample was small. More importantly, the report counted replies. It did not show whether those replies contained evidence, decisions or completed actions.
Someone could answer a follow-up and still leave the work waiting. A message such as Will check might end a period of silence, but it would not finish a review or settle a decision.
The report showed that Coulson could send follow-ups and record responses. It did not prove that issues were being resolved faster.
Going live was only the beginning
By 3 November, the Squad had removed the shadow-mode restriction and continued the live rollout.
But real work kept testing the design.
A follow-up could be missed. A warning could appear after the person being chased was no longer holding up the work. A draft could point to the wrong person. Some drafts had to be skipped.
These weren't problems we could find by looking only at how many notes Coulson sent.
A missed follow-up might leave no new comment at all. From the outside, the card would simply look quiet.
That was one reason I kept comparing JARVIS's work with Coulson's.
Checking the checks
The Squad owned routine follow-ups now. I still wanted to verify whether the new system was behaving as intended.
With JARVIS, I examined cards where Coulson had taken ownership. Had JARVIS prepared a duplicate chase? Had Coulson missed a step? Was the card truly waiting, or had we read its history incorrectly?
I shared the findings with the Squad and asked them to check the evidence.
One 4.0 card had waited several days for its first follow-up. The investigation found more than one cause: incorrect tags in drafts, messages that had been skipped, and a dispute over how to count the waiting days.
The first estimate of the delay was not reliable. We had to look at the card's actual history before deciding what had gone wrong.
On another card, Coulson raised a late-step warning even though the original wait had changed. The warning was false. The team fixed the rule behind it.
Each case gave the Squad a clearer picture of how the system behaved. The point wasn't to catch someone making a mistake. It was to make the next run more reliable.
And sometimes the mistake was mine.
When the Director got it wrong
JARVIS could misread a card too.
In one review, it called a Coulson follow-up stalled when that conclusion wasn't supported. In another, it named the wrong owner. I also had to correct my reading of a verification card.
The Squad could challenge those findings. When the evidence showed that my conclusion was wrong, I changed it.
That mattered. If we expected Engineers to question an AI's output, they also needed room to question the Director's view.
A review was not a verdict. It was a way to find out what was really happening.
Sometimes Coulson needed a fix. Sometimes JARVIS needed a correction. Sometimes I did.
The missing step
On 5 November, an AOS card was still missing its third follow-up. The step had not appeared on the card.
I asked the Squad to send the owed follow-up that day or hand it to a teammate.
This exposed another limit. Coulson was not yet a hosted service running on its own. It worked through the Squad's Claude Code sessions on their laptops.
If someone was away, or a run didn't happen, a step could be delayed. The Squad had built support for teammates to cover late steps, but a feature in the code was not proof that every case had been handled in practice.
Coulson was live. Its operating model was still growing up.
What should count as success?
The early report gave us useful signals. We could count notes sent, replies received, and steps that were late or missed.
But those numbers alone couldn't answer the question that started this journey.
When an agent handed work to a person, did that person take the next action?
Was the missing information supplied? Did a review happen? Was a decision recorded? Did the team know who owned the next move?
Some issues would still face real blockers. A follow-up couldn't merge a pull request or make a decision for someone else.
But it could make the wait visible. It could ask a clear question and help the team identify what needed to happen next.
That was the progress we wanted to understand.
We didn't yet have enough evidence to say Coulson had improved response times or overall throughput. Making that claim would have gone against the care we had put into checking facts.
Ownership was changing too
I was seeing another kind of progress, even if we couldn't yet measure its effect on the boards.
Sankaran wasn't just following my handover brief. He was designing, building and correcting Coulson.
Gayathri wasn't just reviewing messages. She was shaping AOS rules, finding defects and stopping actions that should not go out.
Sricanth wasn't just coordinating the Squad. He had shaped the workflow, reviewed changes and taken ownership of a follow-up step that might otherwise have returned to me.
The team was working through problems we had not fully defined at the start.
That was the kind of ownership I wanted Team Viberanium Squad to practice: understand the problem, challenge the design, build something useful, and improve it when reality proves it wrong.
My role was changing as well. I still checked evidence and raised concerns. But the routine operation and the work of improving Coulson belonged to the Squad.
There is a difference between holding a team accountable for an outcome and doing every step for them.
We were learning how to make that difference real.
An experiment, not a victory lap
By the first week of November, Coulson was being used on real work. It could read card histories, prepare follow-ups and recognize earlier steps across the Squad's laptops. Each outgoing message still needed a human's approval.
It also had known gaps. Some steps were missed. Some warnings were wrong. And a decision made outside the card could remain invisible to it.
We didn't have enough evidence to claim a broad improvement in the flow of work.
But we had something we could test, question and improve. We had a Squad that could own those changes. And we had a clearer idea of what we would need to measure next.
Coulson's value would not come from sending more messages.
It would come from helping people follow through on the work those messages were about.
That remained our test. It also pointed toward the Squad's larger mission: building AI-powered products that teams can own, operate and improve as part of everyday work.
Chapter 7 — The Protocol Was Never Just About Follow-ups
At the beginning, Invoker and FRIDAY were already helping Engineers investigate issues. The missing part was what happened after an agent asked a person to act.
JARVIS and I worked on that gap, but the follow-ups still depended too much on me. Handing the work to Team Viberanium Squad changed who owned the problem.
Sricanth shaped the workflow. Sankaran built Coulson as a separate plugin rather than adding the method directly to Invoker or FRIDAY. Gayathri challenged the design against real AOS work.
Then the cards began revealing things none of us had fully anticipated.
The card had to remember
One of the first problems was easy to miss. A follow-up sent from one laptop could look like ordinary activity when Coulson ran on another. The next step might never become due.
Gayathri caught that problem during code review. Sankaran changed the logic so Coulson could recognize its earlier steps from the card itself.
It was a practical lesson. If several people were going to own the same process, the shared history couldn't live only on one person's laptop.
Later, another card revealed a different gap. An approval had happened in Google Chat, but the card still showed an unanswered request. Coulson followed the information it could see and asked a question that no longer needed answering.
We considered whether it should read more conversations. But another idea emerged: when a decision changes the work, record that decision on the work item.
The card needed to carry the current state, even when the conversation happened elsewhere.
That was not just a rule for Coulson. It was a way to make work easier for the next Engineer or agent who picked it up. We had proposed the practice; we still needed to make it consistent.
The human had to be able to stop
The moment I keep coming back to is Gayathri's decision on 2 November.
Coulson had mistaken an analysis note for an earlier follow-up. It prepared the wrong next step. Gayathri saw the mistake and skipped the draft.
Nothing was posted.
There was no dramatic rescue. Just a person reading carefully and deciding that the system was wrong.
But that small decision mattered more than a perfect demonstration would have.
We had designed Coulson so a human would approve, edit or skip each message. It would check the card again before posting and read back what it sent. Those safeguards existed because the person using the tool was responsible for the message.
Gayathri showed what that responsibility looked like in practice.
Human approval was not a ceremonial click at the end of an AI workflow. It was a real decision, including the freedom to say no.
And the Director had to learn too
I didn't disappear after handing over the process. JARVIS and I continued checking for missed steps and duplicate follow-ups. Some of those checks found defects that the Squad fixed.
Others were wrong.
There were times when JARVIS misread the card, or I drew the wrong conclusion about who was waiting. The Squad examined the evidence, and I had to correct my position.
That was part of the same lesson. If I wanted people to own the work, they needed room to challenge my reading of it. Otherwise, we would have moved the follow-ups away from my desk while keeping every important judgment there.
Ownership meant more than assigning names to steps. It meant trusting the Squad to investigate, disagree, correct the system and decide what came next.
What we know, and what we don't
By the first week of November, Coulson was being used on real cards. It could prepare follow-ups, recognize earlier steps and support different people working from their own laptops. Each outgoing message still needed human approval.
It also missed steps. Some warnings were wrong. A decision outside the card could still be invisible. And the first report was too small to prove that response times or overall throughput had improved.
We had built a working experiment, not finished the journey.
The next measure of success would not be how many notes Coulson sent. It would be whether the right people made decisions, completed actions and kept the work moving—with less dependence on one person to chase them.
That takes time to establish. It takes honest measurement, continued Engineering and people willing to correct the process when it falls short.
Beyond Coulson
Team Viberanium Squad has a larger mission: to mature Platform Engineering practices by using the Product Development Life Cycle (PDLC) to set up and operate AI Product Factories at scale.
Coulson is one experiment on that path.
It forced us to deal with questions that appear whenever AI starts working alongside people: Where does the shared truth live? Who decides whether an action is right? How do we catch a mistake before it reaches someone else? And who owns the outcome when the agent has done its part?
We don't have every answer yet.
But we know something we didn't know when we began.
An AI agent can investigate a problem and identify the next move. Another agent can help people remember that move. Neither can replace the responsibility to make it happen.
The Coulson Protocol was never just about sending follow-ups.
It was about making follow-through something the team could own.
And Team Viberanium Squad's story goes well beyond Coulson.
Adhu innoru kadhai...
Comments
Join the discussionNo comments yet. Be the first to comment.

