Collaboration · Governance · Security

A new normal in software development.

People and agents working as one team. Every role works with AI the same way, every step is governed, and every change is secure and on the record.

Claude Code, Codex, Copilot, Gemini CLIYour models, your keysSSO
One release, start to finish

A team of five ships it in three weeks

Larkfield’s customers keep getting locked out. Watch Sofia, Daniel, Priya, Lukas and Marcus fix it with their agents, every step governed.

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.

What changes

Together, governed, secure

Product, architecture, development, QA and platform work with the same agents and rules, and hand work to each other in the open. Leaders watch, read-only.

Uniform AI →Work with your counterpart →
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.

One catalog of agents, skills and rules. Risky steps stop and ask a named person. Budgets sit on the work, and every action is on the record.

Governance →Token budgets →Audit →
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.

Wakalix never runs the model. Agents use each engineer’s own access, and nothing lands without a person’s yes.

Security →For security teams →
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.

The 5-4-3 promise

Faster, cheaper, right first time

5×

Greater speed

4×

Fewer tokens

3×

Less rework

Proof

About 170 work items in three weeks

One software team in the shipping industry.