Ola Gedenryd — SPCT, Scaled Agile Affiliated Strategic Advisor for Asia, co-founder of Enterprise Movement · 21 August 2026
I wrote this with Claude as my co-writer, and a panel of AI reviewers we built challenged every draft — the same division of labor this article argues for: I set the intent and judged what came back. The experience, the opinions and the responsibility are mine.
We run our whole business on an AI-Native SAFe implementation. Not a pilot on the side — the company itself. Our agents have taken over the accounting from the external accountants we used to pay for it. Invoicing, customer project administration and reporting, marketing, sales — our agents produce that output, and they run on Claude. They also produce the things we lead and work with every day: the plans, the boards, the pull requests. They built the opportunity intelligence that finds and scores tenders for us, and the Academy with its schedule, registrations and certificates — and increasingly they run those too. We humans still lead on outcomes; the agents do all the output.
Those accountants told us recently that nothing in their client base looks like us: an international company with several ERPs, where the agents handle the whole picture — countries, currencies and tax rules included — with a human approving what leaves our accounts and signing what the law says a human must sign. Fifteen people in eight agentic teams make it happen. The details of our company are not the point. The model is, and it runs a real company, with money going out the door every month.
The short version. Production is no longer scarce, so managing output has become mostly a way of being busy. We built our company the other way around: people write intent and judge the evidence at named gates, and the agents produce everything else. This article is the model, what it asks of leaders, and how to start. I am writing it for the leader who has seen AI work once and now has to make it the way the organization runs.
The sentence that changes everything
After the first 45 days of an AI transformation, the question that decides the return is how the work is organized once the agents are inside it. Which model you buy matters far less than the people selling models would like you to believe. The first 45 days end with one workflow delivering value; making the second and the tenth routine is what an operating model is for. Ours is AI-Native SAFe, and it rests on one sentence: people lead on outcomes; agents do all the output.
Most people nod at that sentence. Living by it is much harder than it sounds. It means the things we used to spend our days producing — plans, status reports, drafts, analyses, code — are now produced by agents, continuously and in volume. What is left for us is what the agents cannot do: decide what matters, and judge what comes back.
I know what that costs, because I have paid it myself. Between us we have decades of experience scaling Lean-Agile work inside large enterprises — I have led those transformations and coached thousands of the leaders running them — and every one of us had to start again from the beginning. Most of the practices I have taught over the last fifteen years do not survive this. A Product Owner inside the team, stories written by hand, story points, velocity: none of it holds when agents do the work. Unlearning them in my own company was harder than learning them ever was. Everybody here changed what they do all day, me included. Producing that output used to be my job, and I was good at it. Learning to be useful without producing anything was the hardest part.
What AI-Native SAFe is
SAFe is the framework most large enterprises land on when they scale Lean-Agile work across many teams. I have taught and implemented it for many years, in Europe and in Asia, and I have seen it done well and seen it done as theater.
AI-Native SAFe is Scaled Agile's re-founding of it for a world where agents produce most of the output. It is not the old framework with AI assistants bolted onto the teams — the way of working itself is different. The center of gravity moves from output to outcome: teams are led and measured on the results they move, not on what they produce, because production is no longer the scarce thing. Mik Kersten worked closely with the framework team to anchor it there, and the model draws directly on his Output to Outcome: An Operating Model for the Age of AI (IT Revolution, 2026). If you read one book before you start this, read that one. There are four moves in the model.
Humans set intent. Strategy, outcomes and the measures of success are written by people and stay with people; everything downstream elaborates that intent.
The specification becomes the shared source of truth. It sits between people and agents — not the code, not the slide deck. The agents write it from our intent, and we judge it.
The cadence moves from plan-and-report to sense-and-respond. A short planning event commits the outcomes, then a frequent rhythm reads the evidence and decides.
The portfolio funds outcomes rather than projects. Money follows measurable results and gets re-pointed when the evidence says so.
The structure that carries the four is an outcome tree. Portfolio outcomes at the top; beneath them the outcomes of the ART — the Agile Release Train, which in AI-Native SAFe is a team of agentic teams; beneath those, planning-interval (PI) outcomes and team commitments, each with key results and the evidence that will prove them; and beneath those the specifications and the code the agents produce against them. Intent goes down the tree; evidence comes back up, and the agents do the assembling. People meet the tree at a small number of gates — the points where a named human must say yes before the agents continue. Each gate has its named judge:
- The portfolio owner — whether this is the right outcome
- The team that owns the epic — whether the specification the agents wrote is what they meant
- A human, never the agent — whether the change merges
- One of two named humans — whether it goes to production
How to do it
The framework names the moves. It cannot give you a running instance; you build one, and the practice of running it is what we bring to you. Here is what ours taught us, in the order I would do it again.
Write intent where the agent reads. A team is a few people and their agents. The people own an outcome and hold the gates; the agents draft, build, review and test, all reading the same solution intent — the rulebook in the repository that says how we work. Intent that lives in someone's head, a decision made in a corridor, a customer insight in a private notebook: the agent cannot act on any of it. What isn't in the repo doesn't exist. That includes the plan itself: ours is a pull request a named human approves, and the diff shows exactly what the people decided.
Lead the agent like a team member. It makes all the output. Like every other colleague, it needs to be aligned, to know what we want, and to have the context to do the work well. Most of the "AI isn't good enough" I hear turns out to be a leadership gap: nobody told it what we actually wanted. The boards in our planning room look like anyone's; the agent writes them from the recorded conversations and the people read them. Humans have the dialogue; the agent listens, and the transcript becomes the plan.
Make the specification the contract, and let the pipeline enforce it. Every feature starts as a specification: the agents write it from what the team said it wanted, and a human judges it at the gate. Every scenario in it carries a test, which the agents also write. The pipeline then refuses to merge work with no specification or failing tests, and rejects a change to an epic from a team that does not own it. It runs a security audit on every change, and anything touching authentication or an external integration goes for security review before a human merges it. That is how we let agents build our invoicing and still sleep at night. It has nothing to do with trusting the agent: the specification says what correct means, and the pipeline checks it on every change.
Keep the agent away from the button. Our agents cannot deploy their own code: a hook blocks the deploy command when an agent runs it, and production ships only from a protected workflow one of two named humans approves. The control does not rely on the agent respecting the hook — which is the first thing I would check in anybody's setup, including ours. The agents that run in production do bounded jobs — one scores public tenders and briefs us, another drafts the newsletter — and a human decides what we pursue and what is sent; when one gets it wrong, the damage is a draft somebody discards or a deploy we roll back. When it makes the same mistake twice, the correction becomes a rule.
Twice one of our agents added work to a pull request that had already been closed; now a check refuses the push. You will have your own version of this. Go looking for it early.
Replace the status meeting with Sense & Respond. Planning takes two hours for the whole ART, because the thinking happens all week with the agents and the two hours judge it. Then a weekly hour: what moved (the agents assemble the evidence beforehand), what we built, what we change, and a kill review where work that is not advancing an outcome is explicitly stopped or explicitly kept. Every decision lands as a change to the outcome tree, so the tree's history is the record of why.
Budget tokens like cloud spend. What used to take days now takes hours, and the real question becomes how much compute you want to invest. For us that is a small line next to what it replaces, but it is one to plan and cap per team, and read every week.
Curate the data before you trust an agent with it. Everything above assumes curated, access-controlled data: the tree, the specifications, the rules, each scoped to who may change it and which agent may read it. Ours falls into three tiers — what every agent may read, what is licensed or internal and may be used but never published, and what never goes into a prompt at all: credentials and the personal data we hold for customers. The last tier is enforced where the data lives, not by asking the agent nicely. Read access is the part to get right before you let an agent near anything that matters.
The agents themselves run on Anthropic models — Claude Fable for orchestration, specification and architecture advice; Opus for the coding and QA agents; Sonnet for the reviewers. The setup would work on any stack of models; we chose Anthropic because their commitment to running AI safely, for people and for organizations, sits close to our own purpose, Making Lives Better. We are grateful to be in their partner program.
What changes for the leader
If you run a business unit, the first thing that changes is your own week. You cannot review all the output anymore. What replaces reading everything is judging the few things that decide something: the specification before the agents build to it, the change before it merges, the evidence against the outcome you committed to. The review does not get smaller; it moves to the points where your yes actually changes what happens. The skill that becomes scarce is writing intent clearly enough for an agent to act on, and curating the context it needs to do so. Most of the governance you used to do in meetings happens at gates instead.
Your organization is far larger than ours, and I would not claim the transition is the same size. One repository works because we are 15 people; at your size it becomes one per value stream, with the solution intent shared across them. You have what we do not: a legacy estate the agents must work through rather than around, data whose use is constrained by regulation and by your own security function, procurement, and in many countries a works council that has to be brought along before anyone's work changes. We have not solved those at your scale, and I will not pretend otherwise. What I have seen is that they decide the sequence — which value stream goes first — more than they decide whether the model works. And your judgment capacity is not the whole company, as ours is. It is the small number of people who can actually say yes at a gate, and that is the constraint you will hit first, long before the models are the problem.
What we do not have is an IT function to escalate to: the team that owns a module runs it. You will keep yours, so decide early who gets called at two in the morning — "the agents built it" is not an answer.
The mechanism itself does not change: one tree, ownership enforced by the pipeline rather than by a governance board, a named human at every gate. The first step is the same at any size: take one value stream, design its teams and its outcome tree, set up the pipeline the agents work through, and start learning. Widen from there, and leave the org chart alone until you have. And expect every PI on this model to surface rules you will have to fix afterwards. Ours still does, and we fix them in the open, at the next Sense & Respond.
We help you get there
At Enterprise Movement, our purpose is Making Lives Better — for People, Organizations, and Society, and an operating model where people spend their time on intent and judgment instead of output is that purpose in practice. More than 10,000 people have signed up for Scaled Agile's AI-Native SAFe webinar series, so the interest is clearly there. Partners who actually run their own company on the model are harder to find. We were among the first 13 chartered global partners trusted to deliver the AI-Native program, and everything above is how we run our own company today, not a model we recommend from the outside. We help leadership teams do the same: write the outcome tree, stand up the gates, run the first PI with us in the room and your agents doing the output. By the second PI you should not need us.
Bring us a real challenge and we will give you a free 30-minute consultation: a working conversation about what leading on outcomes would look like in your organization, and where your agents would start.
