Every number is cited to a named source in the notes or labeled directional. The terms Owned Intelligence, the Frontier Slice, the Ownership Stack, the Lock-in Tax, and the Rent-to-Own Curve originate with this guide and are subject to the license on the back cover.
This is a field guide, not an essay. Each page carries one idea, one exhibit, and one takeaway, so a board member can read it in twenty minutes and an engineering lead can build from it for a year. Start with the Executive Summary, then follow the path for your role.
The Guide in One Page, then the self-assessment. You will know your rung.
The Executive Summary and the opening page of each Part.
The stack chapters, the worksheet, the 90-day plan, and your department playbook.
Intelligence is no longer scarce. GPT-3.5-level output got over 280 times cheaper in two years, and open models came within points of closed ones on some benchmarks [1].
Renting carries a Lock-in Tax. Price, retirement, egress, silent change, rate limits, and learning that never becomes yours.
The frontier earns a slice, not the whole. Routing each task to the cheapest model that passes cut cost by up to 98% [2], and by over half in another study [3].
The harness is the first asset to own. Whoever controls every model call controls the model choice, the data, and the cost.
Memory beats a bigger context window. Models use the middle of a long context worst [12]. Own your memory and test it under a budget [10][13].
Small trained models win their jobs. A 1.3B tuned model was preferred over 175B [4]. A 770M model beat 540B on a benchmark task [5].
Tuning became cheap. LoRA cut trainable parameters 10,000 times [6]. QLoRA tuned 65B on one GPU [7].
Learning loops build skill renting cannot. Checked rewards train models that improve on real work [8][14], and real work contains the checks [15].
Every department owns part of the asset. Test sets and data live across the company, not only in IT.
Owning pays back, then compounds. More cost first, less every quarter after, and every task improves the next model.
A frontier model should be a tool you rent for a narrow slice of work, not a dependency your business runs on. Owned Intelligence is the capacity to run, tune, and train models on a stack you control.
Every rented call pays a price you do not set and builds no model you own.
Use a frontier model only for work no owned model can pass. Measure the slice. Shrink it.
Harness, memory, models, and a learning loop. Any open-weight model, swappable.
Three curves moved at once. The price of a given level of intelligence collapsed, open-weight models caught the closed frontier, and small trained models began to beat giant general ones on the tasks they were trained for. Together they turn model ownership from a research project into an operating choice.
The cost of GPT-3.5-level output dropped over 280 times in two years [1].
The best open model now sits within a couple of points of the best closed one on some benchmarks [1].
A 770M model, trained step by step, beat a few-shot 540B model on a benchmark task [5].
Each of these changes alone is a trend. Together they move the sensible default from renting intelligence to owning it, and they do it now, not in some distant future.
| Force | The evidence | What it means for you |
|---|---|---|
| Price collapsed | GPT-3.5-level output over 280x cheaper, 2022 to 2024 [1] | Raw capability is now a commodity input |
| Open caught up | Gap to the best closed model fell to 1.7 points on some benchmarks [1] | You can own a model close to the frontier |
| Small got good | A 770M model beat a 540B model on a benchmark task [5] | Training matters more than size |
| Tuning got cheap | A 65B model tuned on one 48GB GPU [7] | Making a model yours fits a team budget |
| Learning got checkable | Reward given only when an answer is verified correct [14] | Your own work can train your own models |
The Lock-in Tax is the premium an enterprise pays for depending on a model it does not own. The token price is the smallest part of it. The rest is paid in exposure, rework, and learning that never becomes yours.
| Exposure | Early signal | Mitigation | Owner |
|---|---|---|---|
| Price | Rate-card notices, spend rising faster than usage | Route through the harness, keep an owned fallback that passes the test set | CFO |
| Retirement | A retirement notice for a model you depend on | Keep test sets ready so a replacement is validated in days | CTO |
| Data egress | Sensitive fields appear in outbound prompts | Redact at the harness, run sensitive work on owned models | CISO |
| Silent change | Test pass rate drops with no change on your side | Pin versions where offered, run the test set daily | Engineering |
| Rate limits | Errors and queues at peak hours | Put routine bulk on owned capacity | CIO |
| Lost learning | Tasks and outcomes are not being recorded | Log every call and its outcome into owned memory | Every team |
The Frontier Slice is the share of your AI work that genuinely needs a frontier model, because no model you own can pass it yet. It is real, it is valuable, and it is small. Everything outside it belongs on models you control.
Who decides what runs on the frontier? Not a preference and not a vendor default. A test set. Every task gets a set of examples with known good answers, and the cheapest model that passes it gets the work.
Every frontier call goes through your harness. Never straight from an app.
Every call becomes an example you keep, for testing and for training.
Sensitive fields are stripped before anything leaves the building.
Each quarter, owned models retry the slice. What they pass, they take.
Problems with no precedent in your data, where no owned model can be tested yet.
Work so infrequent that tuning a model for it will never pay back.
Drafting training examples for owned models, where the vendor's terms allow it.
A check on high-stakes outputs from owned models, not the first answer.
The Ownership Stack is the system that makes any model yours. A harness that controls every call, memory that keeps what the organization knows, models you run and tune, and a learning loop that turns work into better models. The frontier sits outside, reached through one governed line.
Routing, test sets, guardrails, and logs. Model-agnostic by design.
Kept on your side, and tested under a fixed budget [10].
A 3B open model tuned on 6,444 domain questions and answers [9].
Environments that score real tasks so models improve by reward [8].
| Layer | Build, buy, or configure | Why |
|---|---|---|
| Harness | Build | It is the control point, and it must outlive any model |
| Memory | Build on bought storage | What your organization knows should never sit in a vendor's product |
| Models | Configure open weights, then tune | Start from the best open model, make it yours with your data |
| Learning loop | Build | Your test sets and environments are the asset nobody can copy |
| Compute | Buy or lease | Commodity, so own the choice, not necessarily the hardware |
| Frontier | Rent | For the slice only, through the harness |
The harness is the software every model call passes through, the place where routing, testing, logging, and safety rules live. It is small to build, and it decides everything else. A company that owns its harness can change models in a day. A company that does not is rebuilding every time the market moves.
Memory is everything a model can draw on that is not baked into its weights, from the current task to years of documents and decisions. It is where your knowledge lives, so it must live on your side. A bigger context window is not a substitute. Models use information in the middle of a long context worst [12].
Memory lives in your systems, never inside a vendor's product.
Test memory strategies at the budgets you will actually run [10].
Put the most relevant memory at the start or the end of the context [12].
Every retrieved item carries its source, so every answer can be checked.
Start from the best open-weight model, a model whose weights you can download, run, and change. Then climb the ladder only as far as your test set demands. Much enterprise work can be won on the first three rungs. MEDFIT-LLM, a 3B model tuned with LoRA on domain data, sits on rung two [9].
| Criterion | What to check |
|---|---|
| License | Commercial use allowed, and what the terms say about outputs and tuning |
| Fit | Size after quantization fits the hardware you will serve it on |
| Quality | Pass rate on your own test set, not on a public leaderboard |
| Coverage | Your languages, your domain vocabulary, your document types |
| Tooling | Mature serving runtimes and tuning support exist for it |
| Provenance | Weights come from a verified source, with a known history |
A reinforcement learning environment is a safe practice space. It gives a model real tasks, lets it act, checks the result, and rewards only outcomes that are verified correct [14]. Reasoning skill itself has been built this way [8]. The enterprise advantage is that real work already contains the checks. A public benchmark of 2,294 real software issues uses nothing more than each project's own tests [15].
| Function | What the environment verifies |
|---|---|
| Engineering | The tests pass on a real issue from your own backlog |
| Finance | The reconciliation balances to the ledger |
| Customer support | The customer accepts the resolution without escalation |
| Legal | The clause matches the approved playbook position |
| Sales and solution engineering | The answer matches an approved, current source |
| Operations and IT | The system reaches the expected state after the runbook step |
A test set is a collection of real tasks with known good answers. It is how you know an owned model is good enough, how you catch a vendor's silent change, and how the router decides. It outlives every model you will ever run.
| Metric | Definition |
|---|---|
| Pass rate | Share of test tasks a model gets right |
| Cost per passed task | Spend divided by tasks passed, the true unit cost |
| Coverage | Share of live workloads that have a test set |
| Regressions | Tasks that passed before and fail now |
Owning intelligence does not mean building a data center. It means the stack can run on any tier you choose, and moving between tiers is a configuration change, not a rewrite. A runtime, the software that loads and serves a model, makes that possible.
4-bit weights let a far larger model fit on the same GPU [7].
Pick the smallest model and tier that clears the test set.
A local runtime such as Zorp serves models on hardware you own [11].
Leased capacity is fine when the stack can move off it.
| Area | Rented model | Owned stack |
|---|---|---|
| Where data goes | Leaves your boundary on every call | Stays inside unless routed to the slice |
| Who changes behavior | The vendor, on its own schedule | You, through tested releases |
| Access control | Vendor account settings | Your identity and permission systems |
| Logging | What the vendor chooses to expose | Everything, in a store you own |
| Model supply | The vendor's choice | You verify weights and licenses |
| Updates | Applied by the vendor | Applied by your platform team |
The case for owning is not ideology. Published research shows the same pattern again and again. A model trained on the right data for a defined job matches or beats a far larger general model, and the tools to do that training now fit on a single GPU.
A 3B open model fine-tuned with LoRA on 6,444 domain questions and answers for medicine, one of the most demanding domains there is. Owned, inspectable, and small enough to run in-house [9].
Reasoning was learned through reinforcement learning, then passed into open models from 1.5B to 70B parameters. The learning loop built the skill, and distillation carried it into small models [8].
The Rent-to-Own Curve is the shape of the decision. Owning starts with a build cost renting does not have. Renting carries a cost that rises with every success and a price set by someone else. Past the payback point, every quarter widens the gap.
Routine work moves to models that cost a fraction per task [2].
Fewer of the six Lock-in Tax exposures apply to each workload.
Every task improves the next model, a return renting never pays.
When the market moves, you swap the model, not the business.
The business case for owning is not a forecast. It is arithmetic on numbers you can read from your own systems. Fill this in for one workload first, then add them up.
| Input | Where to get it | Your number | |
|---|---|---|---|
| V | Tasks per year | Harness logs, by workload | |
| s | Frontier Slice share | Share of tasks no owned model passes, from routing logs | |
| cf | Frontier cost per task | Vendor invoice divided by tasks served | |
| co | Owned cost per task | Serving and hardware cost divided by tasks served | |
| B | Build cost | Team time for the quarters it takes, plus compute and tuning |
Counting prompts or seats measures activity. These eight numbers measure whether the company is building an asset or renting one. Review them monthly at the operating level and quarterly at the board.
The single number for the board. What share of AI work runs on models you control.
Spend divided by tasks that passed the test set. Cheap answers that fail are not cheap.
How many days to replace any model. The lower it is, the less the Lock-in Tax can bite.
| The question | A good answer | A red flag |
|---|---|---|
| What share of our AI runs on models we control? | A number, and it rises every quarter | “We use the best vendor.” |
| What happens if our main vendor doubles its price or retires a model? | A tested fallback, and a swap time in days | A plan to renegotiate |
| What is our Frontier Slice, and is it shrinking? | Read from routing logs, trending down | Nobody measures it |
| Do our critical AI workloads have test sets? | Yes, owned by the departments that use them | Quality is judged by demos |
| Where does sensitive data go when AI uses it? | Inside our boundary, or redacted first | “The vendor has a policy.” |
| What do we learn from every AI task? | Outcomes are logged and feed memory and tuning | Nothing is kept |
| What is the payback on the stack? | The worksheet, filled in with our numbers | A vendor's return study |
| Who owns Owned Intelligence? | One accountable executive | Everyone, which means no one |
Two companies can ship the same AI feature and have opposite futures. One owns the system that makes its models better and cheaper with every customer. The other rents a capability any competitor can rent tomorrow.
| Signal | Durable advantage | Rented veneer |
|---|---|---|
| Model dependence | Runs on owned or swappable models | Hard-wired to one vendor |
| Gross margin | Improves with volume as owned models take work | Flat or falling as usage grows |
| Data | Proprietary data feeds memory and tuning | Data passes through, nothing is kept |
| Evaluation | Private test sets tied to customer outcomes | Public benchmarks and demos |
| Learning | Each release gets better from real usage | Improves only when the vendor ships |
| Switching | Can change models in days | A rewrite to change models |
Build in order, because each layer feeds the next. The harness produces the logs, memory keeps them, tuning turns them into models, and the learning loop makes those models better on their own.
| Activity | Council | Platform | Dept. lead | CISO | CFO |
|---|---|---|---|---|---|
| Set the Frontier Slice budget | A | C | I | C | R |
| Run the harness and platform | I | A, R | I | C | I |
| Build and maintain test sets | I | C | A, R | I | I |
| Release an owned model | I | R | A | C | I |
| Set data sensitivity rules | I | R | C | A | I |
| Report the eight metrics | I | R | C | C | A |
R, does the work. A, accountable for the result. C, consulted. I, informed.
No. You still rent it for the slice, and the harness lets you adopt a new frontier model in days.
Not necessarily. Lease or own. Tuning a large model now fits on one GPU [7].
Only where the vendor's terms allow it. Your own data is the safer base.
Five roles to start. See page 43.
It depends on volume and slice size. Use the worksheet, page 27.
Yes. The harness and test sets cost little, and owning compute is optional.
The harness, three workloads, and test sets. See page 41.
Then it does not get the work. The test set decides, task by task.
Cheapest model that passes the test set gets the task.
Harness, memory, models, learning loop. Any model, swappable.
Every task becomes data, and every quarter the slice shrinks.
The share of your AI that would keep running, improving, and paying back if every frontier vendor doubled its price tomorrow.
The work that genuinely needs a frontier model, because no owned model passes its test set yet. Measured, and shrinking.
Harness, memory, models, and a learning loop, owned, with the frontier reached through one governed line.
The full premium of dependence. Price, retirement, egress, silent change, rate limits, and learning that never becomes yours.
Owning costs more first and less every quarter after payback. Renting rises with every success.
Answer for one business unit. A yes needs evidence, a log, a test, or a number.
A practitioner guide, built to be seen first and read second. Owned Intelligence, the Frontier Slice, the Ownership Stack, the Lock-in Tax, and the Rent-to-Own Curve are original constructs of this guide, along with its maturity ladder, operating model, and department playbooks.
They rest on published research on routing and cascades [2][3], tuning and distillation [4][5][6][7], reinforcement learning [8][14], domain fine-tuning [9], memory [10][12][13], real-task environments [15], and local runtimes [11], with market figures from [1].
Exhibits labeled directional show the shape of an argument, not a measurement. The only numbers that matter for your decision are the ones your own routing logs and test sets will produce.
White Paper No. 03, The Future Is Local. White Paper No. 09, The Local Inflection. White Paper No. 11, The Metered Enterprise. All at arjunjaggi.com.
Arjun Jaggi, Owned Intelligence. The 2027 Master Guide to Enterprise Model Strategy, Enterprise AI Research, arjunjaggi.com, November 2026.
Share it freely inside your organization. Pin page 47 by your desk, and run the self-assessment on page 48 with your leadership team each quarter.
Arjun Jaggi writes and advises at the intersection of enterprise AI strategy, the economics of adoption, and the operating work of turning AI into results. His frameworks turn the hardest questions of running AI at scale into terms a board can decide on and a team can execute. Engage at arjunjaggi.com.