Home/Resources/Walkthroughs
Walkthroughs

See it working

One team of five ships its Spring release. Ten narrated walkthroughs, recorded from the real console, each from one seat.

Transcript

Larkfield's customers keep getting locked out. Here is how a team of five, and their agents, fix it, from the first sentence to the release.

Marcus sets the team up once: five people, their tools, and their machines.

Sofia, the product manager, says what customers need, in her own words.

The agent turns it into roadmap items, including one from the team's Jira board. Sofia applies them, and agrees the Spring release.

Daniel, the scrum master, starts one sprint. Every item has a budget in tokens and time, and he approves the plan.

He gives the reset email to Priya. Each item carries the context its agent needs.

Priya starts it in VS Code. Her agent works on her own machine, and she steers it as it goes.

An agent asks Sofia how long a reset link should work. She answers: one hour.

Another question is about how to release. That is not her area, so she passes it to Marcus.

Lukas reviews the work and sends it back once, with a note. The agent reads it, fixes it, and he accepts.

Every answer, every yes, and every change is already on the record.

And Claire, who leads engineering, sees the release move, without a status meeting.

Three weeks after the first sentence, the Spring release ships.

Five times faster, four times fewer tokens, three times less rework. People and agents on one team, every step governed. That is Wakalix.

Transcript

Setting up. How Marcus gets Larkfield ready, once, so the team can just work.

Marcus looks after the platform and security. He invites the team: Sofia in Madrid, Daniel in Chicago, Priya in Bengaluru and Lukas in Berlin. Five seats in all.

He connects the team's code on GitHub.

Each person's own machine runs their agents, with Larkfield's own model. Jira, Azure DevOps and Microsoft sign-in are connected on the machines too.

He decides which agents each person can use, product by product. Priya works on the web app only.

And he writes one rule for every agent: use each engineer's own access, never a shared key.

Five people, four machines, and one set of rules. Larkfield is ready.

Set it up once, and everyone works in the same governed space. That is Wakalix.

Transcript

Roadmap to delivery. How one sentence from Sofia becomes a shipped release, with a team of five.

Sofia is the product manager. Customers keep getting locked out, so she opens the roadmap and says what she wants.

She writes it in her own words, and asks for a request that is waiting on the team's Jira board.

The agent turns it into four roadmap items: Account access, with three features under it. The Excel export came straight from Jira. Nothing changes until Sofia applies it.

Then she puts the three features into the Spring release, with a target date, and agrees it.

Daniel, the scrum master, starts a sprint on Account access. One sprint covers all three features.

The agents split the work into ten small items. People and agents share one board.

Every item has a budget, in tokens and in time. Daniel checks the estimates, then approves the plan.

He gives Send the reset email to Priya, the developer. She picks up Sign in with Microsoft herself.

Each item carries its context: what it builds on, and what the agent will read. So Priya's agent starts with the right information.

Meanwhile, an agent has a question for Sofia: how long should a reset link work, one hour or 24 hours?

She answers: one hour. Her answer goes back to the agent, and the work carries on.

The second question is about how to release. That is not Sofia's area, so she passes it to Marcus, the platform engineer.

Daniel keeps an eye on spend. Every item is measured against its budget. One went over, and everyone can see it.

Three weeks after Sofia's first sentence, the Spring release ships. The old way, a release like this took fifteen weeks.

Five times faster. People and agents on one team, and every step governed. That is Wakalix.

Transcript

The engine. How Priya and her agent build one feature, with Lukas one question away.

Priya is a developer in Bengaluru. She opens VS Code, and her work for today is waiting. She presses Start.

Her agent gets everything it needs: the story, what done means, Lukas's design note, Sofia's answer, and the team's rules.

The agent works on her own machine, with Larkfield's own model. She steers it as it goes: use our existing email template.

She has a design question, so she asks the architect. Lukas answers before any code is written.

She reviews the change against the base, and accepts it. Nothing an agent writes lands without a person's yes.

Lukas sends it back once: a used link still works twice. The next attempt reads his note, fixes it, and adds a test. Then it is accepted.

And a new version of the developer agent only goes live after it passes all forty-two of its tests.

One send-back in the whole feature, because the questions were answered first. Three times less rework. That is Wakalix.

Transcript

The record. Everything the team did is already on record, and nobody had to write it up.

Marcus also looks after security. The audit shows every change in the release: who made it, and why. Nothing here can be edited.

Sofia's answer, one hour, became a rule for every product. It replaced the old 24-hour rule.

The release question Sofia passed on, and Marcus's own answer, are both here.

Lukas sent one change back with a note. The second attempt, and who accepted it, are recorded too.

Who can use which agent, on which product, is clear at a glance.

At the end of the quarter, he downloads the access review for the auditors. It takes a minute, not a week.

Every answer, every yes, and every change, on the record. That is Wakalix.

Transcript

Leadership view. How Claire sees progress, without asking for a status report.

Claire leads engineering at Larkfield. Every Monday she opens Wakalix and sees what moved, across every product.

She picks the web app. The Spring release is two thirds done, and on track for the ninth of December.

The finish date comes from the team's real pace, not from anyone's guess.

Week by week, she sees what shipped and what is in flight, taken from the work itself.

One feature is late. She looks at the open questions. The release question has waited two days for Marcus. Now she knows why, and nobody had to chase anyone.

And the tokens. This release used about a quarter of what the last one did.

Four times fewer tokens, because every agent starts with the right context. That is Wakalix.

Transcript

Secure by default. Before the Spring release goes out, Marcus asks for a security review of the web app.

He opens a security cycle. The security engineer agent reads the code and reports. It attacks nothing and fixes nothing.

First, the agent asks what worries him and which checks he wants. Then it asks who has authorised any testing.

The plan has six pieces of work, from a threat model to a test of the running app. Each one has a budget, and the board measures the work against it.

The threat analysis ranks every threat by risk. A reset link used twice is already covered by Priya's one-use links.

The SBOM, made by the team's own tool, lists every component. The scan finds three advisories, but only one reaches code the app runs. It also says what it could not see.

A scan of Larkfield's own code finds three problems. Each one points to the file and the line, with the fix to make.

The penetration test plan waits for a lead. Lukas asks to run it, and Marcus approves. Nothing is tested until he does.

Only then is the running app tested, on staging, inside the agreed window. Each finding says how to repeat it.

Claire sees the newest threat model, SBOM, scan and test plan for every product, on one page. Anything out of date is marked.

Every release examined, and every test authorised first. Secure by default. That is Wakalix.

Transcript

Where the tokens go. Why AI coding bills grow, and why Larkfield’s did not.

Most teams lose tokens in three ways. They use the biggest model for every job. Their agents chat back and forth, hunting for context. And every session starts from zero.

Wakalix picks the model per skill. Building a change gets the strongest model. Reading and summing up gets a smaller, cheaper one.

And each line of Daniel’s plan can ask for its own model. Simple work goes to the smaller one.

A lot of the work needs no model at all. Checking the plan, checking it may start, the exit check and the evidence are plain, predictable code.

Agents are not chatty. Each one starts with a single packet holding exactly what it needs, so it does not burn tokens hunting for context.

When work pauses for an answer, it picks up the same session afterwards. And packets are laid out so the model reuses its cache. Most of what it reads costs a fraction.

Daniel sees spend by skill, against what was planned. The checks that need no model cost nothing.

Claire sees each person’s own subscription: who has room to spare, and who is close to the limit. Always in tokens, never money.

And the result. This release used about a quarter of the tokens of the last one.

The right model for each job, one packet per agent, no chatter, and the cache reused. Four times fewer tokens. That is Wakalix.

Transcript

One standard, every team. How Larkfield keeps its code consistent when everyone has their own coding agent.

A year on, Larkfield has three teams, in Madrid, Kraków and Pune, and fourteen developers.

Each one works in their own coding tool: Claude Code, Codex, Copilot or OpenCode. Claire wants one way of writing code, not fourteen.

Lukas, the architect, writes a standard once, for the whole organization.

A person checks it in every review. He takes it, and it is in force at once.

Every decision in force goes into the work each agent is given, with the reason it is there. Here it is for Priya, in Claude Code.

And here is the same work packet for Ana, in Kraków, who works in Codex. The same decisions, in the same words.

Every repository also carries the organization's own rules, for whichever coding tool opens it. One upgrade brings a checkout up to date.

Every team uses the same agents, at the same version: the developer agent at version eighteen, the reviewer at nine.

Their tests run here, so everyone can see that every skill still passes.

The reviewer agent checks each change. This one broke the new standard, so it went back with a note saying what to fix.

The next attempt read the note and fixed it, and this time the review passed.

Upkeep reads the notes people leave. Reviewers in three teams sent work back for the same reason, so it proposes a new standard.

Lukas reads what each reviewer said, and keeps it as a standard.

He applies it, and agents read it from their next run.

Decide once, and every agent, in every tool, on every team, works to it. That is Wakalix.

Transcript

Your Wakalix. Everyone sees the part of Wakalix that fits their job.

Marcus turns the persona view on. There is one persona for each role, and Leadership comes built in.

He adds one more, for reviewers, made from the reviewer agent.

A persona is a set of actions, and the home that goes with them. What a person can actually do is still decided by their access.

Sofia picks where she starts: her product persona, and the web app. Then she opens her home.

Her home shows what needs her, her actions, the stories that changed, and her part in each product. Nothing else.

Priya's developer home shows the work waiting on her, and her part in each product.

Lukas wears two hats. He switches from architect to reviewer in one click.

As a reviewer, his home shows the change that waits for his review.

Claire's leadership view needs no setup. She sees how each product is moving.

And the views she needs: security posture, deploys, usage, and who holds what.

Anyone who wants everything can open the classic view, with the full menu, at any time.

The part that fits your job, and everything else one click away. That is Wakalix.