Agents in the ceremonies you already run

A seven-and-a-half-minute film of one real sprint in StellarView, in order from setting up to the release, on the real screens. It is narrated by three of the agents that sat in its meetings. The drawings are labelled as drawings. Below the film is the record behind every number it says, and the list of what is not done.

The sprint is late and nothing is merged yet. Here is the record anyway, because one thing in it may be in your pipeline too: 412 of our agents’ test runs were recorded as passing when no tests had run. How that happened.

Most teams trying agents end up writing their own process for them. A new board, a new set of statuses, a prompt that pretends to be a project manager. We think that is the wrong move. Teams already run a process that works, and most of them run Scrum. The agents should join it.

We took the parts of AI that are most consistent and most capable, and put them to work inside the processes most teams already use to build software. We did it in a way meant to move the people forward, not to replace them. The agents’ work passes the same gates a person’s would, and it leaves the same record.

So in StellarView the agents take seats in the ceremonies a team already holds: Sprint Planning, refinement, the Sprint Review, the retrospective. They read from the team’s own Jira and GitHub. Every point an agent makes cites a fact from a frozen snapshot of those records, and a point that cites nothing is struck before it is said. What the agents propose goes to the person who owns it: the Product Owner for order and scope, the Developers for their plan. Agents prepare. People decide.

This is part three of the series. Part one showed the lifecycle and the evidence rule. Part two opened one meeting. This one follows a whole sprint and its build, and it reports what the record caught us getting wrong.

What is in the film · The build, measured · What the record caught · What is not done

What is in the film

at	what
0:05	One sprint in four numbers
0:39	The seats: one person, one Scrum Master, and the agents
0:56	The flow, in the lens’s twelve steps
1:37	The Big Bang: 16 phases, 268 work units, 480 gaps
2:00	Sprint Planning, prepared by the agents, and stepping in
2:28	The launch, the Conductor, and Mission control’s go or no-go
3:01	The build and the Spectrograph
3:27	Tests judged on evidence, QA by a person, commission and demo
4:13	What was built: SprayPath
4:26	A held deploy, and tuning at the boundary
5:18	The sprint as days across, and who moves each thing
5:52	The Sprint Review with its evidence, and who decides
6:42	Others doing this work

Don’t reinvent the SDLC

A method that works can be written down and tested, then shared and learned. Scrum is one, and StellarView carries it as a lens beside Kanban, SAFe, Waterfall and ITIL. A lens is a file. It names the steps and their meetings, and who passes each gate. A team picks its lens, and the screens use its words. The engine underneath is the same for every lens, and the agents work the same way under all of them.

That shared structure is what makes a cyborg unit possible. Every person on the team is a JOEY, and each has a Commander: an agent tied to their own credentials, with a profile that sets what it knows and may do. A person and their Commander can join a team because the team’s method is already written down in a form both of them can follow.

The house method is Pulse. Pulse is not a different process. It is a stance inside the one you run: don’t wait. Predict what is coming and prepare ahead of it. A meeting’s pre-read is written before the meeting. The calendar says what falls due, and on which day. The agents keep the work moving between meetings, and the people decide when they meet.

The point of a written, tested method is that a person can step into it. A new Scrum Master on a late sprint should not need ten years of context to know what happens next. We want a junior to work like a senior from the first week. The framework brings the context to the step they are on, and the agents carry the detail.

Before this, the details took most of our time, so each of us knew our own corner of the work well and the rest of it barely. Now a person can learn the concepts and let the machines do the detail. That changes what a team can see. The planner sees the build, the developer sees the review, and everyone sees the same record.

One sprint

The sprint in the film is SprayPath, a crop-spraying platform for drone operators, built for Hollingsfield Agtech. Hollingsfield is a demo company we made for a partner, RCH Solutions; the build is real. The sprint ran from 29 September to 6 October.

From the client’s documents, the Big Bang drew the work as 16 phases and 268 work units, and listed 480 gaps: questions the documents did not answer. Each gap was answered or marked open before its phase started, and each answer is kept with the work unit it belongs to.

Sprint Planning was a real meeting. The agents prepared it: each one introduced its part, then took its turn from the records. It ran 8 agent turns and left 16 proposals for a person. It cost $2.16 in model calls. One thing about it was wrong, and it is in the next section but one.

The build, measured

Agents built SprayPath, unit by unit, each in its own Claude Code session. StellarView reads each session’s transcript and draws it in the Spectrograph: every model call as a frame of what it carried in, what it cost and how long it took.

Across the 15 phases with saved findings:

measure	value
build sessions	311
model calls	38,118
compactions (the session hit its context limit and summarised)	356
session time	86.3 hours
cost at Anthropic’s API list prices	$3,268
commits	479 across all branches, 444 on the main line, from 29 September to 7 October
pull requests	16, one per phase

The cost needs one honest note. The build ran on a Claude subscription, not the API. $3,268 is what the same calls would cost at list price, and it is how we compare one phase with another. It is not money spent.

Phase 16, the last, took the platform from local Docker to AWS. The Spectrograph shows it with 15 of 15 units committed, 40 of 40 gaps answered before building, and all four test suites green on their last full run. Not every phase went that way. Phase 6 had 99 of its test runs re-judged, the most of any phase.

Everything an agent did, kept with the work

When a developer works with an AI assistant today, the conversation usually stays in their own chat history. The prompts, the attempts that failed, the tests it ran and the reasons it gave all happen outside what the organisation knows. The next person sees the code and none of the reasoning behind it.

Here, every build session’s transcript is kept, and each one is tied to the work unit it committed. All 311 sessions above can be opened from the phase and the unit they built. Each one shows its calls in order and the model’s own words between them. Every test it ran sits beside them, with its verdict. The meetings are recorded, and each turn keeps the facts it cited. Nothing about how a unit was made depends on one person’s memory.

The same goes for the product itself. The demo station drives the real app the way a person would, screen by screen, and records each one. For SprayPath it walked 65 screens, and the recording became a film of the app at work on the client’s own fields. A new person can watch the real thing being used before they touch it, and that is a faster way to learn it than reading about it.

A walkthrough works the same way. Ask for something and it is shown to you: a film that already exists, or the steps performed on your own instance. Under each film sits its World, a model of every beat, every topic and every fact it cites, so the film can be read, searched and checked as well as watched. Part two opens one.

Every test run, judged on evidence

The commission run boots the whole stack and runs every gate, and it found work the agents had left. The tip they built failed lint, format and typecheck. The commission made 11 fixes on its own branch: a missing build step, formatting over 490 files, test timeouts and a test that leaked its cache, among others. After those, 1,172 of 1,172 integration tests passed. 79 end-to-end tests passed and 10 failed, and the commission wrote down why: a dependency, Field Twin, was not running. Its fixes are not yet in the phase pull requests.

Inside the build, every test run an agent made from phase 6 onward is recorded with its verdict and the reason for it: 1,470 runs. The recorder started at phase 6. A run counts as passed only on a test runner’s own summary of tests that ran and passed. A failed run links to the run that came after it, so an old red line says whether it was fixed.

What the record caught

Three things were wrong, and we found each one because the record was there to read.

412 test runs were recorded as passing without evidence. The first recorder called a run passed whenever it saw no failure. One example was timeout 280 make test-workers 2>&1 | tail -60. On the Mac there is no timeout command, so nothing ran. The pipe then ended in tail’s success. We re-judged all 1,470 runs and kept the old verdict beside each change. 115 had in fact failed, 272 showed no sign that tests ran, and 25 were not test runs at all. Phases 6, 8, 11, 12, 13 and 15 had claimed every suite green when they had not. If you run agents that run tests, check yours.

A meeting’s brief leaked from one product into another. The team that runs SprayPath also runs a second product, Field Twin. Its review brief was written for Field Twin and lived on the team, not the product. When SprayPath’s review prepared itself, the pre-read came out about Field Twin. It cost $0.51 and went to the team’s Telegram before we saw it. Now each engagement carries its own briefs, and a meeting about one engagement reads only that engagement’s records.

SprayPath’s planning read the whole team’s records. It was held before meetings were scoped to an engagement, so its turns drew on both products. The sprint calendar had been counting it as SprayPath’s planning without saying so. It now says the meeting was held by SprayPath’s own station, and that it read the team’s records, not SprayPath’s alone.

The lesson we take from all three is the same one. Trust in agents comes from the framework around them, not from the model alone. Its rules and its scoping matter, and so does a record complete enough to find the mistakes in.

Who moves each thing

The sprint is drawn as days across. Each event sits on its day, and three rows say who moves each thing:

• by itself: the house does it with no one asked. A due meeting’s pre-read, the build, the saves, the watch that checks every running train every two minutes.
• on a click: prepared, and waiting for a person to start it. Holding a meeting, resuming a train.
• a named person: only that person decides. Accepting the review, choosing how unfinished work rolls over.

A dashed line from each item to today says how long it has waited. Any item opens in place with where it stands, what to do next in order, the evidence behind it, how most teams run it, how Pulse runs it, and the same thing in a PMP’s terms.

A meeting, once started, runs on its own. The agents take their turns and it is ready when the team comes to it. A person can step into the recording at any turn, and every agent after them hears it. The team then holds the event: it inspects, adapts and decides.

Others doing this work, side by side

Others are bringing agents into delivery, and each is worth reading. The table compares approaches, not quality. Each cell comes from the product’s own published pages, read on 11 October 2026; a cell we could not confirm says so.

	Where the agents work	How a person takes part	What they read	Who decides	What is kept
Scrum, with assistants on the side	in each developer’s own chat	writing prompts, and judging the answers	what the developer pastes in	the team, in its ceremonies	the code; the chats stay with each person
GitHub Copilot coding agent	an assigned issue, through to a draft pull request	writing the issue, and reviewing code	the repository and the issue	a person reviews the pull request	the pull request, and its test and lint run
Atlassian Rovo	inside Jira: breaking work down, checking readiness, watching delivery risk	in Jira, and by chat with the agent	Jira and Confluence	the person who assigned the work	Jira’s own history; per-call cost not found in its pages
Linear agents	as workspace members you assign or mention	assigning and mentioning in Linear	Linear	the person stays the primary assignee	Linear’s own history
MetaGPT, ChatDev	role-played teams of agents, from one requirement to code	a prompt at the command line	the prompt	the framework’s fixed steps; no human gate found	the generated project
StellarView	seats in the team’s own ceremonies, and the build	a live meeting on a shared stage: the agents speak, a person types a sentence into the room or decides with a button	the team’s Jira and GitHub, frozen per meeting	the owner: Product Owner for order and scope, Developers for their plan	every turn’s cited facts, every session’s transcript and cost, every test run’s verdict

The column that matters most to us is the second one. Most of these approaches ask a person to work the way a developer does: write a good prompt or a good issue, read a diff, judge code. In a StellarView meeting the agents speak from the record on a stage the whole team can watch, in the ceremony they already know. A Product Owner or a new Scrum Master takes part by typing a sentence in the room, or by choosing with a button. The person does not need a developer’s skills to direct the work.

We think working with agents needs a modern interface for the whole team, and a text box is not it. A text box suits the people who already know how to direct a model. A stage, a calendar and a tray that opens each item in place suit everyone else on the team, and they are most of it.

Much of it is not driven by a person at all. A meeting is prepared when its day comes, or when the train reaches its station, and the agents’ turns are ready before anyone opens it. The person comes in to decide.

Where the others are ahead, plainly:

• Reach. The Copilot coding agent has been generally available to paid Copilot subscribers since 25 September 2025, Rovo ships inside Jira plans, and Linear has an open platform with many third-party agents. StellarView has run one team’s work.
• Measuring AI across a whole company. Tools such as Jellyfish and Swarmia report AI spend and adoption across many teams. The Spectrograph measures one team’s sessions in depth.
• Compliance. Several of them publish their certifications. StellarView has none yet.

What we have not found elsewhere is agents taking turns as seats in a team’s own sprint ceremonies, reading that team’s own records, with what they propose routed to the person who owns it. That is the part we are building.

What is not done

• Nothing has landed. The 16 phase pull requests are open and stacked. None is merged to main. In Scrum terms there is no accepted Increment yet.
• The commission’s 11 fixes are on its own branch. They are not in the phase pull requests yet, so the pull requests on their own would still fail lint, format and typecheck.
• Requirements are thinly tied to the work. Of 372 requirements, 23 are named by a work unit, and none yet by a test case. QA Validation shows it, and it is the next thing to close.
• The sprint is late. It ended on 6 October. The deploy has been held since that day, waiting for a database in the cloud, and the Sprint Review has not been held.
• Human time is not measured. We can show what the agents did, minute by minute. We cannot yet show how much of a person’s time the sprint took.
• One team, one real engagement. No team outside ours has run StellarView.
• It fits teams on GitHub and Jira running Scrum. The lenses bend the words and the steps to other methods, but only Pulse has been used. There is no GitLab, Bitbucket, Azure DevOps or Linear integration. The builder is Claude Code, and deploys go to AWS.
• Preparing by itself is paused until SprayPath’s own review brief is confirmed.

The films behind it

The film at the top is the centrepiece. These show the same work from other sides.

Read more

• Part one: every claim cites a fact
• Part two: what a meeting leaves behind
• Pulse Operations

Credits

Narrated by Sue, Roger Rodger and C D Cakes, agents of the JOEY Mob, in synthetic voices over the house bed. Screens captured from StellarView and the SprayPath app on 11 October 2026. Drawings made with manim.