Soundness

A plan can read as a single coherent story from goal to task and still not be true of the company running it. Reading coherent was never the harder test its borrowed name implies, and the test that actually matters isn't about the document at all.

August 28, 2026 9 min read

A quarterly plan names "reduce onboarding time" as a top-level goal. Three months later, nobody on the team can point to a single shipped thing under it, not because the goal was wrong, but because no one ever actually committed a piece of work to it. In the same quarter, a different team has been heads-down the whole time on a project the plan doesn't mention anywhere. Both facts can be true on the same day, in the same company, without anyone lying about anything.

A plan reading well is not the same as a plan being true

Read the doc top to bottom and it looks fine. The goal is named, a rationale sits underneath it, an initiative sits under that, and the initiative points at a team. Every level connects to the level below it in the prose. That's what makes the gap easy to miss: the plan isn't internally inconsistent, it's disconnected from what's actually happening in the systems where work gets committed and shipped. A document can be a coherent story and still not correspond to the org it claims to describe.

That's a different failure than a plan being wrong. A wrong goal is still a real goal, just a bad bet. A goal that was written down and never connected to any committed work isn't a bad bet, it's a sentence sitting in a doc with nothing underneath it, doing no work at all.

Where this gets its name

There's a term worth borrowing from a different field, workflow management, not because it applies to a document directly, but because of what it demands that a document alone can never supply. In 1998, Wil van der Aalst published "The Application of Petri Nets to Workflow Management" (Journal of Circuits, Systems and Computers), applying Petri net theory to model business processes as networks of states and steps, then defining exactly when such a model is trustworthy enough to build on. He called that property soundness, and it comes down to three requirements, all of them about the model's own reachable states, none of which check the model against the real world: from anywhere the process can be, there's still a way to reach proper completion, reaching completion never leaves anything else in the model half-finished, and every step the model defines is one the model's own wiring actually permits, not one that's drawn in but can never fire.

That distinction matters more than the borrowed word. A sound workflow net is not a net proven to reflect real practice, it's a net proven not to contradict itself. Whether it reflects real practice is a separate question entirely, and it has its own name and its own primary source: Anne Rozinat and Wil van der Aalst's "Conformance Checking of Processes Based on Monitoring Real Behavior" (Information Systems, 2008) defines conformance checking as exactly this, comparing a process model against a recorded event log of what a system actually did, not inspecting the model alone.

Applying the test to a plan

Read a strategy doc next to that definition and the mismatch shows up immediately. Soundness is a property of an actual process model, places and transitions with markings that can be traced through reachable states. A prose document was never built as one of those, so there's no reachable marking anywhere in a paragraph to check, and a strategy doc can't strictly pass or fail soundness at all, there's no formal object there to run the test on. What a plan gets cheaply, almost automatically, is a much weaker property: internal coherence. Every goal has a rationale, every rationale points at an initiative, every initiative points at a team, and nothing in that graph contradicts itself on the page. Prose is good at having that property whether or not anything underneath it is real.

The question that actually matters is a different one, and it isn't a question about the document at all. Is there still a real, committed path from where the work actually stands today to each stated goal, not a path the doc asserts, but one that shows up in real work items? When a goal is marked reached, is there other work still claimed under it that never actually finished, sitting there indefinitely? Does every goal the plan names have at least one piece of committed work under it right now, rather than sitting in the document as a line nothing was ever assigned to move? And is there real, committed work happening right now that isn't under any of those goals at all, activity the plan's own picture simply has no place for? None of those are questions a document can answer about itself. They're questions about whether the plan matches something outside it, checked the way process-mining research checks a model against what a system actually did: not by rereading the model, but by comparing it against the record.

A goal with no committed work today and a workflow step nobody can ever reach share a shape, by analogy rather than by formal equivalence, something a model includes that the real system never produces, but they aren't proven the same way. A dead transition is dead because of the net's own wiring: no sequence of steps, ever, can reach it. A goal with no committed work today might get some next sprint; checking it only tells you what's true right now, not what's structurally impossible forever. That difference is exactly why this check has to run against a live record instead of getting decided once. A structural proof about a Petri net stays true forever. A check like this is only as current as the data it's compared against.

The honest limit

Soundness, in van der Aalst's actual sense, was never a test a prose document could pass or fail in the first place, there's no process model there to check reachability against. What a plan gets for free is a much weaker property, internal coherence, prose that doesn't contradict itself. That's exactly why internal coherence is the wrong thing to check for reassurance: it's cheap precisely because it was never the hard test to begin with. The property that costs something, and the one that actually tells you anything, is whether the plan corresponds to real committed work, a claim about the world rather than about the document, and checkable only against a record of the world that's actually current.

Even a plan that clears both, prose that holds together and goals demonstrably tied to real committed work, can still be built around the wrong goals. Clearing both tells you the document is honest about the company. It says nothing about whether the company is betting on the right things.

Checking a plan against real work also depends on that work being visible and current in the first place, which is Work Agent's job: a canonical, live record of what work actually exists is what makes the check possible at all. Without it, there is only the plan's own account of itself, and a document was never going to catch its own gap with reality by rereading itself.

Where this fits at Brief

This is the job Strategy Agent is built around: pulling vision, goals, and OKRs out of the documents where they live, so the top of the plan sits in the same picture as the work at the bottom, the picture this kind of check needs to run against in the first place. A plan kept only in a doc can look complete indefinitely, because nothing about rereading it will ever surface the gap.

Pull up your team's current top-level goals. For each one, could you point at a specific piece of work committed to it right now, or would you be pointing at the sentence that names the goal and calling that the same thing?

Frequently asked questions

What does "soundness" mean applied to a strategic plan? In van der Aalst's original sense, soundness is a structural property of an actual process model, places and transitions with markings, checkable by analyzing the model's own reachable states. A prose strategy document was never built as one of those, so it can't strictly pass or fail that test at all. What it gets for free is a much weaker, cheaper property, internal coherence, prose that doesn't contradict itself. The check that actually matters for a plan, whether its goals correspond to real committed work, is a different and much harder property, not soundness itself, but the same discipline of testing a model against something outside it instead of trusting it on its own account.

Where does this idea come from? Wil van der Aalst's 1998 paper applying Petri net theory to workflow management defined soundness for process models: every reachable state has a path to proper completion, completion never leaves something else unfinished, and every modeled step can actually occur, three questions answerable from the model's own structure, with no need to check it against the real world. Comparing a model to what a system actually did, the harder question this post is really about, is a separate, related line of process-mining research usually called conformance checking.

Isn't a plan that reads coherently good enough? No, and that's the trap the borrowed term exposes. A plan can be internally coherent top to bottom, reading as a single unbroken story from goal to task, while having goals nothing is actually committed to and work happening the plan never mentions. Internal coherence is nearly free. Whether the plan is true of the company is the expensive, harder question, and it's the one that actually matters.

Why does this depend on Work Agent's data? Because checking a goal against real committed work is a comparison to something outside the plan, not a property of the plan itself, and that comparison only means anything if the record of real work is current. Without a live, canonical account of what work actually exists, the only account available is the plan's own, which is exactly the account this whole check exists to stop trusting on its own word.