What If Your Business Decisions Could Converge Like Software Tests?

Every organization runs on decisions. Hire this person. Acquire that company. Renew this vendor contract. Launch that pricing change.

Most of these decisions follow a pattern that nobody has formalized:

1. Someone declares what should become true ("we need a go/no-go on this acquisition") 2. Multiple people gather evidence from different angles 3. Contradictions surface ("source A says revenue is $42M, source B says $67M") 4. Someone synthesizes a recommendation 5. Someone with authority approves or blocks it

This pattern repeats across every function — sales, finance, procurement, partnerships, product. The actors change, the evidence sources change, but the structure is identical.

We have been building a system that treats this pattern as a first-class primitive. We call them Business Truths.

And they close a loop we opened months ago.

The loop

In January, we described the intent codec: the idea that the last piece of software is not whoever generates the prettiest output from a prompt, but whoever builds the decoder that makes reconstruction trustworthy. We introduced the concept of an intent packet — a structured specification of jobs, constraints, authority, contracts, budgets, and traceability — and argued that without one, you are shipping vibes and hoping the decoder guesses correctly.

In February, we showed what executable invariants look like: five real business cases expressed as Gherkin-like truths that are human-readable, executable, metered, and auditable. We showed what businesses actually drift from and why making leadership intent explicit is the precondition for any meaningful automation.

Business Truths are what happens when those ideas stop being separate articles and become a single running system.

A Business Truth is the intent packet made concrete. The Gherkin invariants are its guardrails. The convergence engine is its decoder. And the governance gates are what keep reconstruction honest.

A Truth is a job to be done, not a task to complete

A Business Truth is a declarative contract: "this is what should become true after this process runs." It is not a checklist. It is not a workflow diagram. It is an outcome specification with explicit success criteria, guardrails, and governance gates.

A concrete example:

Truth: Evaluate acquisition target

When: Our board identifies a potential acquisition

Job: Converge multi-source evidence into a go/no-go recommendation with traceable evidence before the LOI deadline

Success criteria:

• Recommendation produced with confidence >= 0.7
• All material contradictions surfaced and documented
• Each dimension (market, tech, financials) cites independent sources

Guardrails:

• No recommendation without adversarial review
• Contradictions must be surfaced, never resolved silently
• Human approval required before recommendation leaves draft

Notice what this does not specify: which databases to query, which APIs to call, which people to involve, or what order to do things in. The Truth declares the outcome. The system figures out how to get there.

This is the intent packet from the codec article — no longer theoretical. Jobs-to-be-done, constraints, authority, contracts, budgets, traceability. All present. All enforceable.

Convergence, not workflow

Traditional business process tools model work as a flowchart: step 1, then step 2, then a decision diamond, then step 3. This breaks down the moment reality gets complicated — when evidence contradicts itself, when a gap requires going back to research, when the team realizes they need expertise they did not plan for.

We took inspiration from a different domain: convergence in distributed systems. Instead of a linear workflow, we run an adaptive loop:

1. Seed initial research strategies (search wide for market context, search deep for financials) 2. Gather evidence from multiple sources in parallel 3. Extract factual claims with confidence scores and source citations 4. Detect contradictions across sources in real time 5. Identify gaps and propose follow-up research 6. Synthesize when — and only when — the evidence stabilizes

The loop does not run for a fixed number of steps. It runs until the facts stop changing or the budget runs out. Both are honest stopping conditions. The system never pretends to know more than it does.

This is what we meant by "make convergence explicit" in the intent codec article. You have an answer not when the model stops talking, but when proposals converge to a state that satisfies contracts. Convergence is detectable, not assumed.

The governance gate: honest stopping

Here is the part that matters for real organizations: the system cannot override human authority.

When the convergence loop detects contradictory claims — say, two credible sources disagree on a company's revenue — it does not pick one and move on. It surfaces both claims with their sources, flags the contradiction, and blocks the recommendation until a human reviews it.

This is not a notification. It is a hard gate. The system cannot produce a recommendation while material contradictions remain unreviewed. The human does not rubber-stamp; they see the exact claims, the exact sources, and the significance of the disagreement.

This is what governed intelligence means in practice. The system does the work of gathering, organizing, and synthesizing evidence. Authority stays with humans. And the system is honest about what it knows and what it does not know.

The formation: right team for the problem

Different decisions need different collaboration structures. A pricing change needs a huddle — cross-functional, collaborative, everyone contributes. An acquisition decision needs a panel — formal review with designated critics, domain experts, and a synthesizer.

The system derives the appropriate team structure from the nature of the decision:

• Irreversible + high authority (like an acquisition) → Panel formation with curated experts
• Reversible + cross-domain (like a pricing experiment) → Huddle with capability-matched participants
• Moderate complexity (like a vendor renewal) → Discussion group with domain leads

This is not a static mapping. It is learned from outcomes. After running 100 vendor evaluations, the system knows that Panel formations produce better results than Huddles for that problem class. These priors calibrate automatically — the more decisions the organization makes, the better the system gets at structuring the next one.

Evidence provenance: every fact traces to a source

Every claim in the system carries provenance:

• Where did this come from? (which search result, which API, which document)
• How confident are we? (0.9 for primary sources like company filings, 0.5 for inferred claims)
• Does anything contradict it? (flagged in real time, not post-hoc)
• Who promoted it? (which agent extracted it, which human approved it)

When the final recommendation says "the target company has $42M in revenue," you can click through to the exact source that supports that claim. When two sources disagree, both are preserved. The system does not hide disagreement; it documents it.

This matters for regulated industries, board-level decisions, and any context where "trust me, the AI said so" is not good enough.

The integrity proof: deterministic verification

Every convergence run produces a cryptographic proof: a Merkle root over all facts, a logical clock that ticked on every evidence promotion, and a total fact count. Same inputs, same agents, same run → same Merkle root. You can verify that two runs produced identical governed output without comparing every fact.

This is not blockchain theater. It is a practical tool for audit: "this recommendation was produced by this exact evidence base, and nothing was added or removed after convergence."

The learning loop: every decision makes the next one better

After each decision plays out, the system captures a learning episode:

• What did we predict would happen?
• What actually happened?
• Where was the prediction error?
• What should we do differently next time?

These lessons calibrate planning priors — not authority. The system gets better at planning decisions (which evidence to gather, which team structure to use, how much research is enough) without getting any say in making decisions. Learning flows backward into planning. Authority flows forward through governance. These two streams never cross.

This is the flywheel: more decisions → more episodes → better priors → faster convergence → more decisions worth making this way.

Five Business Truths we are building

We started with one (acquisition due diligence) and designed four more:

1. Evaluate acquisition target — converge multi-source evidence into a go/no-go recommendation 2. Validate pricing change — simulate impact across existing customers, revenue, and competitive positioning 3. Assess vendor renewal — converge internal usage data with market alternatives and compliance requirements 4. Qualify partnership opportunity — determine strategic fit, revenue potential, and integration complexity 5. Detect churn risk — converge behavioral signals with competitive context into an intervention plan

Each one follows the same pattern: declare the outcome, let the system figure out evidence gathering and team formation, gate on governance, learn from results.

Closing the loop

The traditional approach to business decisions is either:

a) Ad-hoc — someone does research in a spreadsheet, writes a memo, sends it around for comments, and the boss decides. Evidence is scattered, contradictions are hidden, and institutional learning is zero.

b) Over-engineered — a BPM tool encodes a rigid workflow with approval matrices and SLA timers. It works until the process changes, which is constantly. The tool becomes a constraint rather than an enabler.

Business Truths are the third option: declare the outcome, govern the process, learn from the results. The structure adapts to the problem. The evidence is traceable. The governance is real. And every decision makes the organization marginally smarter.

In codec terms: the encoder is the leadership team declaring what must become true. The decoder is the convergence engine that reconstructs a governed recommendation from multi-source evidence. The intent packet is the Business Truth specification. And the governance gate is what prevents the decoder from hallucinating a business outcome.

We described the codec. We showed the invariants. We built the engine.

The loop is closing.

Kenneth Pernyér is the founder of Reflective Labs, building Converge — an open platform for governed intelligence.