Bottom line up front: On June 14, 2026, Microsoft’s CEO published an essay describing the future of the firm in an AI-driven economy. He is right that the ecosystem matters more than the model, that human and token capital compound together, and that the companies who build a proprietary learning loop early will have an advantage that is hard to replicate. He is also writing for organizations that already have structured data, documented processes, and a governance layer to feed that loop. Most small businesses have none of the three. This post is the on-ramp he skipped — and the framework that got there first. Paper #8 in the Thought-OS™ reading order.

Don Lovett, Fractional CFO & Managing Principal · ProjectBits Consulting · June 2026

The 8-Layer AI Stack: from the model and memory foundation up through retrieval, the system of record, and production-grade security — the governed ecosystem an SMB needs before the learning loop Nadella describes can compound.

What Nadella Said

Satya Nadella published an essay this week titled A frontier without an ecosystem is not stable. It is worth reading in full. The core argument is this:

Every company will need to build two forms of capital simultaneously — human capital (the knowledge, judgment, relationships, and pattern recognition of its people) and token capital (the AI capability it builds and owns). These compound together. Human agency sets direction, connects dots across domains, and recognizes which patterns matter. AI executes, learns, and extends that judgment at scale. The learning loop that results — the system that improves with every interaction — becomes the intellectual property of the firm.

He called it a hill-climbing machine.

He also named the sovereign control test every company needs to pass: a company should be able to switch out a generalist model without losing the institutional knowledge built into its learning system. If that knowledge lives inside someone else’s model and someone else’s infrastructure, you have not built a learning loop. You have rented one.

He is right on all of it. And he is writing for companies with multi-million dollar AI budgets, data science teams, internal evals infrastructure, and engineering organizations that can build agentic systems from scratch.

That is not the managed service provider (MSP) with $2 million in annual revenue. It is not the trades business doing $5M in service calls. It is not the consulting practice that runs on QuickBooks Online (QBO) and a professional services automation (PSA) tool that does not talk to the books. It is not any business where the owner is also the chief financial officer (CFO), the sales team, and the person figuring out why the reconciliation is off at 10pm on a Sunday.

ProjectBits has been a Microsoft Partner for years. We know the stack he is describing from the inside — QBO, Microsoft 365, Teams, the Graph application programming interface (API), Entra, Outlook. We also know what the businesses that will never appear in a Microsoft keynote look like from the inside. The hill-climbing machine Nadella describes has a foundation. He assumed it. This post names it.

The Foundation He Assumed

Three things have to be in place before Nadella’s learning loop produces output you can act on, trust, and defend.

Governed data — structured and unstructured. You already have both. The structured side — QuickBooks transactions, PSA job records, payment processor feeds — is in your systems right now. The question is whether it is in a state a model can reason over: the same vendor named consistently, job codes that held their meaning, categories that reflect what actually happened. When it is, a model can answer questions about your business. When it isn’t, the model spends its time untangling your history instead of reading it.

The unstructured side is where most of your institutional knowledge already lives: the receipts and expense documentation you filed, the business licenses you renewed, the work tickets your crew completed, the vendor contracts you negotiated, the IRS substantiation notes you wrote, the subcontractor agreements you signed. For a trades business, that work ticket is the record connecting a bank feed entry to a specific client, crew, and material cost — information the owner carries and the books don’t. For an MSP, the support ticket thread holds the real story of a client relationship that no PSA summary captures. That knowledge exists. It was built by the owner, the crew, the team. The work is making it findable — linked to the transaction it explains, classified, retrievable at the moment someone asks why that client’s margin was negative last quarter rather than buried in a folder that hasn’t been opened since the job closed.

Getting meaning out of unstructured data takes work the vendor pitch decks skip: chunking strategy, embedding, retrieval design, linkage back to the transaction the document substantiates. A folder of PDFs dropped into a chatbot is not a knowledge base. It is a pile with a search box.

Documented processes. You already know how a job gets priced, how an onboarding exception gets handled, how a reconciliation discrepancy gets resolved. You have been making those calls for years. The work is writing them down — not because the judgment is wrong but because AI can only inherit what is explicit. When the process is documented, the model executes your logic. When it isn’t, the model invents a version of it that looks right and belongs to nobody.

A governance layer. Your policies exist — in your head, in how you run your team, in the corrections you make when something goes wrong. The work is encoding them mechanically so they run without you having to be in every decision. That is what Nadella means by private evals: a measurement system grounded in your outcomes, not an external benchmark. It requires a baseline. The baseline requires that the policies are written down and enforced before anything gets measured.

The architecture underneath that governance layer matters as much as the policies themselves. We use the model to design and reason over tasks, then execute through predictable, deterministic flows — n8n (an open-source workflow automation tool) and Python code where the steps, sequencing, and outputs are defined in advance. The model classifies, recommends, and drafts. The workflow executes, routes, and logs. That division is deliberate. It narrows the surface area where the model can hand you a surprise result. An agentic system given an open-ended goal and the tools to pursue it will pursue it — sometimes efficiently, sometimes expensively, occasionally both at once. Bounded flows with defined exit conditions and a human review step at the threshold that matters are less impressive to demo and far more defensible in production. The policy engine sits above both layers, enforcing the authority rules that the workflow cannot override and the model cannot reason its way around.

The operational case for this is not theoretical. A 20-year-old transaction processing system at a large government jurisdiction produced an incorrect log entry showing failed transactions. The operator, reading the log at face value, reran the batch. The transactions were not failed — they had completed. The rerun created duplicates. The team spent 48 straight hours backing them out. The system did not lie. The log was ambiguous, the operator made a reasonable call based on what the log appeared to say, and the cost of that ambiguity was two days of remediation that should never have been necessary. A tamper-evident, append-only audit log with a verified sequence does not prevent every mistake. It does mean the operator reads the history with confidence rather than inference — and that the decision to rerun, or not, is made on a record that cannot have been silently altered between the failure and the review.

The owner of a $5M trades business or a $3M MSP has spent years building exactly the knowledge Nadella is describing — client relationships, margin intuition, operational judgment, hard-won pattern recognition about what works and what doesn’t. That is the human capital he says compounds with token capital. The foundation work is not about acquiring knowledge you don’t have. It is about making the knowledge you already have legible to the system that will extend it.

The Staircase We Built Before He Named the Machine

There is a timing point worth making explicitly, because it is the difference between validation and imitation.

The Financial Maturity Staircase — ProjectBits’ application of Carnegie Mellon’s Capability Maturity Model to small-business financial operations — was published before Satya Nadella wrote a word about hill-climbing machines. The seven-step framework at projectbits.com/financial-maturity-staircase describes the same sequential climb Nadella is calling for, applied to the operational domain where most small businesses actually need to start: their books.

The parallel is structural. Both frameworks share the same underlying logic — that improvement compounds, that each stage is prerequisite to the next, and that the organizations that build the foundation early accumulate an advantage that is hard to replicate regardless of any new individual capability that emerges above them. But the staircase maps something Nadella’s essay leaves abstract: the specific rungs, what you can do from each one, and what is structurally blocked until you climb it.

Steps 1 and 2 — Recorded and Accurate — are the data governance precondition. Transactions exist and are correctly classified, reconciled, and current. Without this there is no reliable signal for any model to reason over. A model applied to Step 1 books does not produce intelligence. It produces confident noise at scale.

Steps 3 and 4 — Connected and Compliant — are the integration and policy layer. Revenue streams and operational systems feed into the books through validated connections. Written policies are encoded and scored against 51 criteria across five domains. This is where Nadella’s policy-as-code concept lands in practice for a small business: not a Rego policy engine on day one (Rego is the policy language behind the Open Policy Agent, the open-source engine we run in production), but documented standards applied consistently and measured on a schedule. The score is not an opinion. It is the output of a compliance check you can show a lender or an auditor.

Steps 5 and 6 — Visible and Predictive — are where the learning loop begins to produce the outputs Nadella describes: key performance indicators (KPIs), trend analysis, rolling forecasts, scenario models. Every business owner who has tried to build a cash flow forecast on top of messy books knows the failure mode: the model is only as honest as the inputs, and the inputs are not honest.

Step 7 — Coached — is Nadella’s hill-climbing machine at small-business scale. The data, the predictive models, and the governance framework are synthesized by a human-plus-AI advisory layer that does not just report what is happening but recommends specific actions, tracks whether those actions were taken, and measures whether they produced the expected result. The machine gets better with every cycle because the institutional knowledge feeding it is governed, accurate, and linked to outcomes that matter to the business.

Nadella called this a private eval system. We call it a monthly close review against a living scorecard. The mechanism is the same.

Which brings us to a discipline that has been making this argument since 1992.

The Committee of Sponsoring Organizations — COSO — published the Internal Control Integrated Framework the year the web was invented. Its five components — control environment, risk assessment, control activities, information and communication, and monitoring — are the governance architecture that the Financial Maturity Staircase applies to financial operations. Governance, risk, and compliance (GRC) as a formal discipline built on that foundation and then got deprioritized during the move-fast era, because compliance felt like friction against velocity.

Now the projects that skipped it are producing the Starbucks inventory debacles and the Uber token budget implosions, and suddenly the COSO control environment looks less like bureaucracy and more like the thing that would have caught this before it compounded.

COSO has been right about this since 1992. The AI era is just the latest proof.

The staircase was the path to the hill-climbing machine before anyone had a name for the destination. The governance discipline underneath it is older than the internet.

What the Machine Actually Looks Like

The AI Stack diagram above was produced using Fable 5 — the same model the Commerce Department ordered offline three days after launch. The architecture it illustrates, the policies that govern it, the audit trail underneath it, and the institutional knowledge it encodes are not going anywhere. The model was rented for the task. The work product is ours. That is the point, and we will return to it.

This week we completed the AI-Stack control plane — the governance layer that sits above our inference infrastructure. It is worth describing concretely because abstract architecture arguments are easy and the receipts are specific.

An append-only decision ledger. Every decision made by every AI actor in the system is logged durably — immutable by design, with mutation blocked at the database level. Every budget decision, every invoice classification, every policy evaluation leaves a permanent record. If something goes wrong, there is a thread to pull. If a model changes and output quality shifts, the log shows when and where. The operator who reruns a batch because the log said the transactions failed needs to know the log is telling the truth — that what it shows is what happened, in the sequence it happened, without amendment. That confidence is an engineering property, not a promise.

Tamper-evidence does not require a blockchain. The word that comes up whenever audit trails and AI governance share a sentence is blockchain — the pitch being that a distributed ledger nobody controls means nobody can quietly alter the record. The mechanism is real. The overhead is also real, and for a small business it is almost always disproportionate to the problem being solved. Our decision log achieves tamper-evidence through two standard PostgreSQL mechanisms that require no additional infrastructure. The first is a grant architecture: the append role holds INSERT only — no UPDATE, no DELETE. A decision lands in the log and the database will not issue the Structured Query Language (SQL) that removes it. The second is a BEFORE UPDATE/DELETE trigger that fires regardless of which credential is used — a superuser attempting a mutation is blocked before the operation completes. For the Five Questions Test benchmark we added a cryptographic hash chain: each record contains a hash of its own content plus the hash of the previous record, with a verify-chain function that flags any break. Together these produce tamper-evident audit logs that a lender, auditor, or acquiring party can interrogate and trust, running entirely inside a standard PostgreSQL instance. No token economics. No distributed consensus. No vendor.

A budget circuit-breaker. Eighteen autonomous AI actors in the system — invoice processing, meeting transcription, contact classification, draft generation, policy conversion — each has a defined token and cost ceiling per day and per month, grounded in observed usage, not guesswork. We made a deliberate choice to run advisory-first: over-budget and kill-switch events are logged but processing continues. The hard-deny flip happens after the caps are trusted. Build the measurement infrastructure first, establish the baseline, then enforce. The same principle applies to any client deploying AI in their bookkeeping workflow.

The OpenClaw case is the receipts for why this matters. Peter Steinberger, the developer behind OpenClaw, posted a screenshot showing $1,305,088.81 in OpenAI API charges over 30 days — 603 billion tokens across 7.6 million requests, run by roughly 100 autonomous Codex instances managed by a team of three. OpenAI covered the bill, which Steinberger framed as research into what software development looks like without budget constraints. The instructive detail for everyone else: disabling Fast Mode alone — a single configuration choice in the harness — would have reduced the raw cost by roughly 70%. A budget circuit-breaker surfaces that decision before the first billing cycle closes. This is not a story about a reckless developer. It is a story about what happens when a sophisticated practitioner runs an autonomous agent harness without a spending governance layer and discovers the rate only after the screenshot. Not malice, not incompetence — an unnamed decision compounding silently until the bill arrives. That is the AI Debt pattern at infrastructure scale.

Policy-as-code enforcement. The invoice approval workflow runs Open Policy Agent (OPA) and Rego policies in production. Authority rules — who can approve what, at what dollar threshold, with what multi-signer requirements — are written in a policy language, enforced mechanically, and logged against the decision ledger. The human above the loop authored the policy. The system enforces it. The override path requires authority to be demonstrated, not claimed. This is what Nadella’s private evals look like at small-business scale: not a benchmark against an external leaderboard, but a measurement against the outcomes that matter to the business — did the right person approve the invoice, did the classification match the policy, did the AI suggestion get overridden and why.

The durable infrastructure — not the model. If Nadella is right that the model is not the point, then the current advice cycle — Mac Mini or Nvidia Spark, local model or cloud subscription, buy once or pay monthly — has the question backwards. Models are commodities you route to. The durable investment is the layer underneath: a secrets and credential store that holds every API key and service token in the system, rotated on schedule, audited on every access, so that when a model vendor changes their API the credential update happens in one place; isolated compute per workload so that when a workflow fails the failure stays in its container and the decision log keeps writing; a governed knowledge layer where institutional knowledge lives in PostgreSQL, portable across model swaps; and observability as a first-class output — every AI actor, its ceilings, its spend, and its posture visible in a single query.

We ran local inference against the financial classification, policy conversion, and reconciliation tasks our practice actually produces for clients. The results were often not good enough for client-facing work. Local models at this scale lose the thread on complex financial documents, miss edge cases in classification logic, produce policy code that requires more correction than it saves. The subscription cost you eliminated is not a saving if the work has to be redone. That finding changed how we think about the infrastructure question: the model choice is a routing decision, and the infrastructure that matters is whatever makes that routing reliable, auditable, and recoverable when something goes wrong. The routing table — which tasks justify frontier model spend, which run adequately on local inference, what each costs per actor per month at observed usage — was built from production test results, not vendor benchmarks. A viral benchmark circulating this past week about local graphics processing unit (GPU) cards turned out to be fabricated. We verified it against our own infrastructure. Verify against source; do not carry forward what you cannot trace. That is the same discipline the Financial Maturity Staircase asks of financial data.

The pendulum between on-prem AI and cloud frontier models is not new. It is the client-server cycle playing out on a compressed timeline — mainframe terminals gave way to fat clients, fat clients gave way to thin clients and web apps, cloud software-as-a-service (SaaS), and now edge compute with enough local inference to matter again. Both extremes have been partially right in every prior cycle and the pendulum has always swung past the point where either held permanently. What is different this time is that the pendulum swing does not resolve the governance question either way. Whether the compute is in a rack in your office or in a Microsoft Azure datacenter, the institutional knowledge, the audit trail, the policy enforcement, and the credential layer still have to be built. The client-server era produced businesses with data scattered across local servers that nobody could migrate or recover. The cloud SaaS era produced businesses with data locked in vendor silos they could not export. The on-prem AI era is setting up the same trap with a different label: GPU in the closet, model weights you own, and institutional knowledge you still have not governed.

The pendulum swings. The foundation requirement does not.

The Crystal Ball No Longer Points One Way

The conventional assumption underlying most small-business AI advice has been that models improve monotonically — that whatever capability ceiling you hit today, the next version clears it, and the direction of the arrow is reliably upward. That assumption is no longer safe. It stopped being safe from two directions at once.

The first is the bootlegged training data litigation. Frontier models were trained on content obtained through pirate libraries and shadow datasets built to circumvent copyright. The settlements already won — including the largest AI copyright settlement in history — required not just payment but destruction of the infringing datasets. When training content is removed, the model changes. It does not announce what it forgot. It answers the same questions with the same apparent confidence. The depth and reliability of its reasoning in affected domains shifts on a schedule set by litigation, not by your production calendar. The direction of that shift is not upward.

The second happened this week. On June 13, 2026 — three days after Anthropic launched Fable 5 to its full user base — the Trump administration issued an export control directive citing national security concerns, requiring Anthropic to suspend all access to Fable 5 for any foreign national, including Anthropic’s own employees. Anthropic said it had to abruptly disable access for all customers to ensure compliance. A model that was fully available Monday was fully offline Friday. Anthropic disagreed that a narrow potential jailbreak should be cause for recalling a commercial model deployed to hundreds of millions of people — but the model came down while the standoff plays out between its CEO and the Commerce Secretary.

The diagram at the top of this post was produced using Fable 5. The architecture it illustrates, the policies that govern it, the audit trail underneath it, and the institutional knowledge it encodes are not going anywhere. The model was rented for the task. The work product is ours. Own your data and your harness path. Rent the model.

The crystal ball that once pointed reliably upward now has a contested direction — shaped by litigation schedules, export control directives, and standoffs between technology companies and federal agencies. A frontier model can go from launch to offline in 72 hours for reasons that have nothing to do with capability, nothing to do with your workflows, and nothing that appears on any vendor roadmap.

This is precisely why the durable investment is the governance layer. If your institutional knowledge lives in a governed knowledge store, your policies live in version-controlled files, and your decision history lives in an immutable ledger — then when the model changes, degrades, goes offline, or gets replaced, the foundation holds. You route to whatever model is available and appropriate. The hill-climbing machine keeps climbing because the institutional knowledge it runs on is yours, not the vendor’s.

The On-Ramp

Nadella’s sovereign control test — can you switch out the generalist model without losing the company veteran expertise? — has a diagnostic version every small business owner can answer today.

Can your books answer five questions on demand?

1. What did we make last month, and is that number right?
2. Which clients are actually profitable, and which ones are consuming margin we cannot see?
3. What does our cash position look like sixty days from now?
4. Where are the jobs running over, and do we know before the invoice goes out?
5. If a lender or acquirer asked for three years of clean financials tomorrow, what would they find?

If the answer to any of these is "I would have to pull that together" or "I am not sure" or "the books are not quite clean enough to trust that number" — the foundation is not ready to support the hill-climbing machine. Not because the machine is wrong. Because the machine needs ground to stand on.

That is the work that comes first. And it is buildable, on a defined timeline, with measurable progress artifacts you hold in your hand at every stage.

The Stable Equilibrium

Nadella closed his essay with a vision of the stable equilibrium: every company owning the learning loop that encodes its institutional knowledge, compounding its human and token capital, with value flowing broadly across every company, every industry, every country. Employees seeing their expertise amplified, their judgment made replicable and scalable, the benefits accruing to the companies and communities around them.

That equilibrium is achievable. It requires the foundational work to be done before the agentic systems are deployed. It requires processes to be documented before they are automated. It requires humans to be positioned above the loop before the loop is closed. It requires the audit trail to be defined before the first decision is made and the first token is spent.

COSO figured this out in 1992. The Financial Maturity Staircase applied it to small-business financial operations before anyone called it a hill-climbing machine. The AI era is making the case for governance that practitioners have been making for thirty years — louder now, and with more expensive consequences for the businesses that skip it.

The hill-climbing machine is worth building. Build the foundation first.

The Five Questions above are the short form of the Five Questions Test — Paper #6 in the ProjectBits whitepaper series, backed by an empirical benchmark run against live financial data and a live policy pipeline. The full paper is at projectbits.com/insights/five-questions-test.

The Financial Maturity Staircase and the path to advisory readiness are at projectbits.com/financial-maturity-staircase and projectbits.com/method.

Don Lovett is the founder of ProjectBits Consulting, a fractional CFO and bookkeeping firm serving small businesses in the $500K–$50M range. He is the author of Tax Ready Bookkeeping and the developer of the CFO Operating System™. He writes about financial governance, AI in practice, and what the numbers actually mean for the owners who built them.

This paper is the eighth in the ProjectBits reading order. Read the series in order at projectbits.com/method. It is the ecosystem view — what Satya Nadella got right about the learning loop, and the SMB foundation he skipped.

ProjectBits Consulting · projectbits.com/method · Reston, VA. ProjectBits Thought-OS™ and Tax Ready Bookkeeping™ are trademarks of ProjectBits Consulting, Inc. This paper is published for practitioner and client education.