# Building Reliable, yet Smart Workflows for Finance, Wealth and Insurance

Karthic Rao · AI Engineer NYC 2026 · October 13

[Watch recording](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17425s)

[04:50:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17425s) Hello, I'm Karthic, CTO at Perpetual.

[04:50:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17428s) In this presentation, I'll talk about building workflows that are both reliable and intelligent for finance, wealth and insurance.

[04:50:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17435s) In regulated domains, workflows must be reliable enough to meet regulatory standards while still being intelligent enough to handle the real world.

[04:50:43](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17443s) In fields such as finance and wealth management, this presents both a technical and a compliance issue.

[04:50:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17448s) Reliability and intelligence are not opposites.

[04:50:51](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17451s) It is up to you where you draw the boundary between them.

[04:50:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17454s) And that is the point of this talk, deciding where that boundary lies.

[04:50:57](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17457s) For us, it's not merely a thought experiment, but a question that surfaces serious consequences.

[04:51:03](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17463s) Perpetual is a wealth management roll-up.

[04:51:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17465s) We acquire running traditional wealth management firms.

[04:51:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17468s) And we maximize their throughput and revenue with the help of AI.

[04:51:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17473s) Wealth management is a regulated industry.

[04:51:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17475s) And that is where we build with AI in production.

[04:51:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17478s) Everything in this talk is grounded in building for those constraints.

[04:51:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17483s) Workflows in finance and wealth management come with four facts,

[04:51:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17486s) and each of them pushes the architecture in the same direction.

[04:51:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17490s) First, they're complex and they need runtime strategies as the process unfolds.

[04:51:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17494s) You can't script every path in advance.

[04:51:37](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17497s) Second, the data is sensitive, so you need a path to move these workflows entirely onto privately hosted models.

[04:51:43](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17503s) Third, in a highly regulated industry, a policy violation isn't a bug report.

[04:51:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17508s) It has severe consequences.

[04:51:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17510s) So, fourth, execution has to be highly reliable and deterministic.

[04:51:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17515s) Inject intelligence only where runtime judgment is genuinely required

[04:51:59](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17519s) and minimize reliance on LLMs everywhere else.

[04:52:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17524s) AI is spreading through regulated industries,

[04:52:07](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17527s) but there's still no consensus on an architecture

[04:52:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17529s) that gives you high reliability with the least use of LLM intelligence.

[04:52:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17533s) Meanwhile, most of what developers hear from the big labs is how to burn more tokens.

[04:52:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17538s) But in a regulated industry, token maxing is the wrong goal.

[04:52:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17542s) These tasks are close to main.

[04:52:24](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17544s) You can lay them out in advance and build them into a massive state machine.

[04:52:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17548s) And that machine needs only a sprinkle of intelligence to navigate it.

[04:52:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17551s) Most steps just follow the next edge.

[04:52:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17554s) Only at a few judgment points does the model pick a branch.

[04:52:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17558s) So the intelligent way to build is to use intelligence minimally and on purpose.

[04:52:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17565s) Let's make this concrete with a real wealth management workflow.

[04:52:49](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17569s) A wealth advisor turns to their assistant and says one sentence.

[04:52:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17573s) Fill out the IRS W-9 for Mr. Harper to a person that's a simple instruction.

[04:52:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17578s) Watch what it actually triggers when a human being executes it.

[04:53:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17582s) The task has complexities that go beyond what meets the eye.

[04:53:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17586s) First, the assistant finds form W-9 from the firm's records or from the IRS website.

[04:53:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17591s) Then they look for Mr Harper in the system of record and find

[04:53:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17594s) three Harper households. So they call the advisor. Which Harper

[04:53:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17598s) do you mean? Only once that ambiguity is resolved do they move

[04:53:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17601s) on to the form. A lookup, an ambiguity and a human in the loop

[04:53:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17605s) all in the first minute of a one line task.

[04:53:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17614s) Filling a form sounds like data entry. It isn't. Every form is a

[04:53:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17618s) small program. A W9 first decides who the taxpayer is, the person or the owner if it's a disregarded

[04:53:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17626s) entity. A foreign person stops right here because they need a W8 instead. Then how they're taxed?

[04:53:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17633s) Exactly one box on line 3A and an LLC adds its letter. That decides which name goes on line 1

[04:54:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17640s) and which on line 2. Then whose number? An SSN or an EIN. Never both. Taken from a verified document.

[04:54:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17648s) never from memory. Exemption codes apply only to some entities and never to an S-corporation.

[04:54:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17654s) And finally, who signs under penalties of perjury? Each answer changes the next question

[04:54:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17659s) and the people involved only ever see three kinds of gates, a question, a document to collect, or

[04:54:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17665s) a signature. Now they start filling the form and realize the system of record is missing three of

[04:54:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17675s) the values it needs. They check the documents on file and the system of record again still

[04:54:41](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17681s) missing so they start an email thread with the client asking for exactly those three

[04:54:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17685s) values. The task now depends on someone outside the firm on their timeline.

[04:54:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17695s) now the workflow waits. The request is with the client and all three values are still

[04:55:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17700s) missing. If the client doesn't reply within two days, the assistant follows up and brings

[04:55:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17705s) it to the advisor at the daily stand up. If the client replies with only two of the three values,

[04:55:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17709s) they follow up again for the missing one. When all three arrive, they complete the form and write

[04:55:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17714s) the new information back to the system of record, including the trail of how they obtained those

[04:55:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17719s) values. In this industry, how you know a value matters as much as the value itself.

[04:55:33](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17733s) Once the form is filled, it goes out for e-signature.

[04:55:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17736s) If the client doesn't sign within a day or two, the assistant nudges them again.

[04:55:41](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17741s) Once it's signed, they file it for the client, send the acknowledgement and update the advisor

[04:55:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17746s) at the next day's stand-up.

[04:55:47](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17747s) One sentence from the advisor became a process that runs for days, crosses several systems,

[04:55:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17752s) weights on two people and loops back on itself more than once.

[04:56:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17770s) Look at what's inside that one sentence. Ambiguity to resolve

[04:56:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17776s) data together. Approvals, weights measured in days, follow-up loops and an

[04:56:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17782s) evidence trail at the end.

[04:56:29](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17789s) Workflow automation tools exist, but they rarely handle this real-world complexity and

[04:56:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17794s) ambiguity.

[04:56:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17795s) A fixed flowchart breaks at the first witch harbour and the lack of a native system of

[04:56:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17800s) record with an integration and an agent that improvises its way through is exactly what

[04:56:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17805s) a compliance team can't sign off on.

[04:56:47](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17807s) One breaks on ambiguity, the other can't be signed off.

[04:56:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17810s) neither handles what's inside that sentence. So what do we do about it? The fashionable framing

[04:56:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17816s) is more agency and better models. Given agent the whole task and wait for the next model to

[04:57:03](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17823s) make it reliable. The reflexive answer, especially inside regulated firms, is the opposite. Less

[04:57:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17829s) agency, more rules, lock it down and hard code every path. Both are the wrong axis.

[04:57:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17836s) In regulated verticals, reliability comes from where you place the boundary between the two,

[04:57:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17842s) between the parts that must be deterministic and the parts that genuinely need judgment.

[04:57:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17847s) Here's the principle.

[04:57:29](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17849s) Determinism governs control flow, evidence, and side effects.

[04:57:33](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17853s) What runs next, what we know, and how we know it, and anything that changes the world,

[04:57:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17858s) like a record written, an email sent, or a form filed.

[04:57:47](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17867s) Intelligence provides interpretation and judgment. Reading an ambiguous instruction, deciding which Harper, understanding a client's reply. The model answers a typed question and the deterministic system decides what to do with the answer and the interplay is recursive. A judgment can open a new smaller plan that's compiled, gated and deterministic again. You'll see that in a moment with follow ups. The boundary between the two is the design.

[04:58:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17895s) Here's how that works in the workflow engine we've built.

[04:58:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17906s) The request goes to a planner. That is a model call and its

[04:58:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17911s) only job is translation. It emits a typed semantic graph of

[04:58:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17915s) intents, entities, facts, artifacts, events, and

[04:58:39](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17919s) constraints, each grounded in the words of the request with any

[04:58:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17922s) any ambiguities it found. Every node points back to the words

[04:58:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17926s) it came from. That graph goes to a compiler that never calls a

[04:58:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17930s) model. In 11 deterministic stages, it turns the graph into

[04:58:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17933s) an execution tag or it fails closed. There are only three

[04:58:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17938s) verdicts. Valid needs clarification or refused.

[04:59:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17944s) Which Harper comes back as a question, not a guess. The plan is

[04:59:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17948s) is compiled, immutable and pinned by its hash.

[04:59:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17961s) The model translates. The plan is compiled. The compiler checks

[04:59:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17966s) the plan against the grammar. The vocabulary of what the firm

[04:59:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17970s) is allowed to do. 42 typed action contracts across forms,

[04:59:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17974s) documents, email, e-signature, calendar and human steps.

[04:59:39](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17979s) Each action the planner asks for has to match a contract. Here

[04:59:44](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17984s) form fill finds its forms contract and locks in. If the

[04:59:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17988s) planner asks for an action that isn't in the grammar or wires

[04:59:51](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17991s) one up wrong, the compiler refuses.

[04:59:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17994s) There are about 40 ways to fail closed from a cycle in the graph

[04:59:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=17998s) to an unsupported action

[05:00:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18000s) And the same contract digest is pinned in the engine, the backend and the UI. So all three agree on what an action means. That is what a closed domain buys you. The model can only ask for things the firm already knows how to do safely. Here is a compiled plan for a W9 chase. Send the client the form, wait for it to come back, check it and file it.

[05:00:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18021s) Before anything runs, a person approves the plan itself.

[05:00:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18026s) Find the form, prepare it for the client to fill, render the PDF and draft the email.

[05:00:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18031s) Drafting is a model call, so it is violet.

[05:00:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18038s) Sending is an action gate. Nothing leaves the firm until a person approves that exact email.

[05:00:44](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18044s) Then the plan waits for a reply and a judge steps in to read it.

[05:00:49](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18049s) The returned form is verified. If it matches, it's archived behind another gate. If it doesn't,

[05:00:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18056s) the plan follows up. Now look at the dashed steps. Rendering the PDF, attaching it, judging the reply.

[05:01:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18065s) The planner never asked for them. The grammar added them because the contracts require them.

[05:01:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18071s) In the story, waiting, approvals, and follow-ups were most of the work.

[05:01:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18075s) Here there are nodes in the plan, not prompts. A reply wait defaults to 72 hours and an explicit

[05:01:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18083s) deadline can be anything from a minute to 30 days. When it passes, a rule decides what happens,

[05:01:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18090s) not a model. One approval covers the plan and every external action like sending an email or

[05:01:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18096s) a signature request has its own gate. The approval is tied to a hash of the exact payload and it's

[05:01:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18102s) checked again right before sending. When a client replies with only part of what we asked,

[05:01:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18108s) the reply judge marks it partial. That judgment is provisional. The step stays blocked until a

[05:01:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18114s) person confirms it. A person confirms it and the step unblocks. Then the follow-up runs as a new

[05:02:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18120s) child plan. The approved parent is never changed and there are at most five rounds.

[05:02:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18131s) Once a plan is approved, a state machine runs it. It picks every step and records every result.

[05:02:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18138s) When a step needs judgment, it makes one fixed schema model call. Compose an email, judge or

[05:02:24](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18144s) reply, spot missing values, extract fields, verify a document. The answer comes back typed,

[05:02:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18151s) and the state machine decides what to do with it. Side effects get a life cycle of their own.

[05:02:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18156s) Prepare, dispatching, succeeded, or when the world doesn't answer cleanly, outcome unknown,

[05:02:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18162s) and manual review. There are no automatic retries. A chat message can approve a step

[05:02:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18168s) or answer a question. It can't change an already approved plan. The model steers. It never drives.

[05:03:01](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18181s) Now look at what is left for the model to do. Outside the planner, the judgments are

[05:03:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18185s) small and typed. Is this reply complete? Does this document match? Which field is which?

[05:03:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18191s) They don't need frontier intelligence. A fast small model, the flash tier, can handle

[05:03:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18197s) them. In this illustrative run of 20 decisions, 19 go to the flash tier and one goes to the

[05:03:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18203s) frontier. That is why we designed for about 95% of model decisions in a workflow never

[05:03:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18210s) never needing a frontier model and the flash tier can run on

[05:03:33](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18213s) hardware you control. Only the genuinely hard cases go to a

[05:03:37](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18217s) frontier model.

[05:03:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18220s) the 5% is not a permanent tax because every judgment is

[05:03:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18225s) typed and logged and the provisional ones are confirmed

[05:03:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18228s) or rejected by a person. Each frontier decision produces

[05:03:51](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18231s) eval grade distribution real training data by construction.

[05:03:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18235s) That data can post train the flash tier. Logging and evals

[05:04:01](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18241s) exist today. The training loop is next. So the frontier share

[05:04:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18245s) shrinks release over release until even the hard cases run

[05:04:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18249s) locally.

[05:04:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18256s) Remember the requirement we started with because data is

[05:04:20](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18260s) sensitive. You need a path to move workflows entirely to

[05:04:24](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18264s) privately hosted LLMs. So can this design really get there? Take

[05:04:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18268s) one type call from the Harper Burbinine plan. Every model call

[05:04:33](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18273s) is small, typed and checked against a schema. So pointing it

[05:04:37](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18277s) at a privately hosted model is a configuration change, not a

[05:04:41](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18281s) rewrite. One line changes and the same answer comes back. Every

[05:04:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18285s) other call has that same small type shape. So the same change

[05:04:49](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18289s) applies to almost all of them.

[05:04:51](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18291s) That is how about 95% local inference becomes viable as an architectural consequence, not a policy promise.

[05:04:59](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18299s) That is the path that sensitive data demands and compliance risk goes down as an engineering roadmap, release by release.

[05:05:07](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18307s) So if you remember one thing, don't ask whether your system should have more agency or less.

[05:05:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18314s) Ask where the boundary is.

[05:05:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18315s) Let determinism govern control flow, evidence and side effects.

[05:05:20](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18320s) Let intelligence handle interpretation and judgment.

[05:05:24](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18324s) At typed points, you can inspect and use every judgment you log to need less of it next time.

[05:05:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18330s) Ask where the boundary is. Thank you.

[05:05:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=18332s) I'm Karthic, CTO at Perpetual.