DEV Community: Shishir Mishra

Why Most AI Pilots Never Reach Production

Shishir Mishra — Mon, 21 Sep 2026 07:44:08 +0000

Originally published at korixinc.com.

Most enterprise AI never leaves the pilot. Stanford's 2025 AI Index reports 78% of organizations now use AI, yet MIT's NANDA initiative found only about 5% of custom enterprise AI tools ever reach production with real value. Adoption is soaring; deployment is stuck. This is the data on why pilots stall — and the three decisions that move AI from demo to deployed.

By Shishir Mishra · Founder & Systems Architect (AI), KORIX · Updated 22 June 2026

Everyone is adopting AI. Almost no one is shipping it.

The adoption numbers look like a triumph. Per Stanford's 2025 AI Index, 78% of organizations reported using AI in 2024, up from 55% a year earlier — a 23-point jump, one of the fastest enterprise-tech adoption jumps on record. Corporate AI investment hit $252.3 billion.

Adoption is soaring — production is not.

Metric	Figure
Organizations using AI (Stanford AI Index, 2025)	78%
Custom AI tools reaching production (MIT NANDA, 2025)	~5%

Trying AI and running AI are not the same thing. The space between these two numbers is where most budgets quietly disappear.

A company can adopt a dozen AI tools and still have nothing in production doing real work. That gap — adoption without deployment — is the single most important, least-discussed fact in enterprise AI today, and it is why a rising "AI adoption" number on a board slide can hide a portfolio of pilots that will never ship.

The production gap, by the numbers

MIT's NANDA initiative, based at the MIT Media Lab, studied 300+ public AI deployments and found roughly 95% of enterprise generative-AI pilots deliver zero return — only ~5% capture meaningful value. Tellingly, AI built with specialized partners succeeded about twice as often as internal DIY builds (≈67% vs ≈33%).

Gartner puts 30–50% of GenAI projects as abandoned after proof-of-concept. The named causes: poor data quality, weak risk controls, escalating cost, unclear value.

Read that list again. Every item is an integration or governance failure — not "the model wasn't smart enough." That is the whole game.

The four ways pilots die

Strip the headlines down and almost every stalled pilot dies one of four deaths — the exact failure modes Gartner names, compounded by what MIT calls the "learning gap": generic tools that never adapt to a real workflow.

1. Data quality. The model is fine; the data feeding it is fragmented, stale, or trapped in systems that don't talk.

2. Weak risk controls. Works in a sandbox, then stalls the moment a security review asks where the data goes.

3. Escalating cost. A demo is cheap; production reliability, monitoring, and integration are not. Budget runs out first.

4. Unclear value. No single measurable outcome was scoped, so the project drifts until a CFO quietly kills it.

None of these four are model problems — and that matters, because most teams respond to a stalled pilot by shopping for a better model when the real fix is upstream: how the work was scoped, integrated, and governed.

What separates the few that ship: three decisions

The fixes aren't exotic. The projects that reach production make three decisions at the very start — and they map directly onto the failure causes above.

1. Build inside the stack they already own

The fastest way to kill a pilot is to make people adopt another platform — the adoption cost and migration risk that tops every failure list. Building AI inside Salesforce, HubSpot, Microsoft 365, or SAP removes the migration entirely. KORIX calls this Bring Your Own Software (BYOS).

2. Govern it from day one

Data residency, access controls, auditability, ownership — built in, not bolted on after a security review stalls the rollout. It's the "inadequate risk controls" Gartner blames.

3. Scope to production, not a perpetual pilot

One real use case, shipped on a fixed 21-day path — not a six-month discovery that quietly dies. As KORIX founder Shishir Mishra puts it: the question was never whether the model is clever, it's whether anyone will be using it in three weeks.

Three ways to "do AI" — and why two stall

Same goal, three routes. The first two fail on exactly the causes MIT and Gartner name; the third is built to avoid them.

	Off-the-shelf platform	Perpetual pilot / DIY	KORIX — BYOS + governed
Adoption	New platform to learn + migrate into	Open-ended effort, no owner	Inside tools the team already uses
Governance	Data leaves; controls bolted on	Often an afterthought	Day-one; data stays put
To production	Months	Often never	21 days
Ownership	Vendor owns it	Unclear	You own code, models & docs

Will your pilot reach production? A quick test

Before you greenlight an AI pilot, answer four questions honestly. Each maps to a failure mode above. Two or more "no"s and you are statistically building one of the 95%.

Does it run inside software your team already uses — or require adopting something new?
Is data residency and access control designed in now, or left for "later"?
Is there one measurable outcome and a hard date — or an open-ended scope?
Do you own the output at the end — or rent it forever?

The receipts: four projects, all in production

We hold ourselves to the same bar. Four of KORIX's last four projects reached production — two carry verified 5-star Clutch reviews, and one is the operating system we run on ourselves.

Proteinverse (e-commerce + AI ops) — order-to-shipment cut from 15–20 min to under 90 sec (measured, before/after); 221 products live across 40+ brands; Lighthouse mobile 91/100 at launch; security review: 24 issues fixed. 5★ Clutch.
Numerology Matrix (custom AI application) — live in production by Day 18. 5★ Clutch.
Lead Intelligence (B2B SaaS pilot) — live in production by Day 21, on the fixed pilot timeline.
KORIX Brain (our own department OS) — a governed AI operating system across Founder's Office, Marketing, Sales, Finance & Engineering. Built for KORIX, run on KORIX.

Who this is not for — honestly

Governed, production-first AI is not the right fit for everyone, and pretending otherwise is how agencies sell projects that should never start. It isn't for you if you don't yet have a software stack worth building on. It isn't for you if what you want is a cheap, off-the-shelf subscription; this is custom build work, typically $15,000–$40,000, not a monthly seat. And it isn't for you if you need something live next week — production-grade AI takes weeks, not a weekend.

The trade-off: BYOS asks for a clear use case and a willingness to govern data properly up front, in exchange for a system that survives contact with production. If that's wrong for where you are, a lighter tool is the honest answer — and we'll say so on the first call.

Methodology — and the honest caveats

Our sample is small. We say so. Four projects is a small, deliberately-disclosed operator sample — directional evidence, not a statistical claim. We set it beside the industry's large-N figures as context, never a like-for-like rate.

How we define "production." Software that is live and in daily use doing real work for the client or for us — not a demo, a sandbox, or a slide.

On the "95% fail" stat. The widely-quoted MIT figure has been publicly debated. We cite it as MIT reported it and name the debate — the honest number matters more than the dramatic one.

The bottom line

The AI that fails isn't dumb — it's undeployed. Pilots die on integration, governance, cost, and unclear value, not on model IQ. The work that ships is built inside the tools people already use, governed from the first day, and scoped to a real production outcome. That's not a secret. It's a set of decisions — and they're the ones we make every time.

Sources: Stanford HAI, 2025 AI Index Report · MIT NANDA, "The GenAI Divide: State of AI in Business 2025" · Gartner, "30% of GenAI Projects Abandoned After POC" (Jul 2024) and "Why 50% of GenAI Projects Fail" (Jan 2026).

Originally published at https://korixinc.com/learning-center/state-of-ai-adoption

AI Agency vs In-House vs Consultancy: 2026 Guide

Shishir Mishra — Sat, 19 Sep 2026 07:54:49 +0000

There's no single best way to get AI delivered — only the right fit for your situation — and sometimes the honest answer is to not adopt AI yet at all. Hire in-house when AI is your permanent core and you can wait two quarters to staff it. Use a big consultancy when you need board-level process and brand cover more than a shipped system. Use a specialist agency when you want a governed, owned system live in your stack in weeks. The costly mistake is mismatching the route to the need.

Most "AI agency vs in-house vs consultancy" articles are written by whoever is selling one of the three. This one is written by an agency that will, below, tell you exactly when not to hire us. KORIX founder Shishir Mishra has spent nineteen years building and inheriting software systems, and the pattern across failed AI projects is rarely the model — it's that the delivery route was wrong for the company's actual situation. A team that needed one shipped use case hired three engineers and waited six months. A company that needed deep internal capability outsourced it to a black box. The mismatch, not the technology, is what burned the budget.

This guide compares the three routes on the four things buyers actually decide on — cost, time-to-value, ownership, and ongoing risk — with real numbers, the honest downside of each, and a plain answer to "which one is right for me." By the end you'll be able to place your own situation on the map, including the cases where the right answer is "not KORIX."

The three routes to AI — and what each one actually sells

KORIX defines the AI delivery decision as a choice between three products, not three vendors: in-house teams sell permanent capability, big consultancies sell strategy and cover, and specialist agencies sell a shipped, owned system. Confusing the three is why so many AI budgets disappear — you cannot buy a fast production system from a route that sells two-quarter capability-building, and you cannot buy permanent internal muscle from a route that sells a finished deliverable.

The context that makes this decision urgent is the gap between adoption and deployment. Stanford's 2025 AI Index found that 78% of organizations used AI in 2024. Yet MIT's NANDA initiative found only about 5% of custom enterprise AI pilots reach production with meaningful value. And Gartner's estimate of generative-AI projects abandoned after proof-of-concept rose from at least 30% to at least 50% by the end of 2025. Adoption is universal; deployment is rare. The route you choose is the single biggest lever on which side of that line you land.

Option 1 — Hire in-house: permanent capability, two-quarter ramp

Building an internal AI team is the right move when AI is a core, permanent part of what you do — not a project but a muscle you'll use for years. The upside is real: full control, deep context, and people who live inside your business every day.

The honest cost. A senior AI/ML engineer in 2026 is a 3–6 month search followed by $150,000–$250,000+ in total annual compensation — before they have shipped anything. You're also hiring into a thin market; McKinsey's State of AI research has repeatedly documented how scarce production-grade AI talent remains. Then there's the hidden tax: one engineer isn't a team, ramp time is real, and if the person leaves, the capability leaves with them. In-house is the highest-ceiling, slowest-to-first-output route — and it only pays back if you have enough sustained AI work to keep that team busy.

Option 2 — Big consultancy: strategy, process, and cover

Accenture, Deloitte, McKinsey and their peers sell something genuinely valuable to large organizations: a defensible process, board-level change management, and the brand cover that lets a CIO say "we engaged a top-tier firm." For a regulated enterprise running a transformation across thousands of people, that is not a vanity purchase — it's risk management.

The honest cost. That cover comes through a multi-month discovery phase and large blended teams, with engagements that commonly run into six and seven figures. The trade-off most buyers underestimate is speed and ownership: first shipped value typically lands months in, and what gets built is often tied to the firm's own platforms, frameworks, or an ongoing retainer. You're buying process and certainty, not a fast, independently-owned system.

Option 3 — Specialist AI agency: a shipped, owned system, fast

A specialist agency sells the thing the other two routes treat as a by-product: a working, governed system in production, owned by you. The model is narrow on purpose — one real use case, built inside the software your team already uses, on a fixed short timeline, with the code and documentation handed over at the end.

The honest cost — in writing. A KORIX engagement typically runs $15,000–$40,000 for a defined production system, and the pilot path is 21 days to a live use case. Naming that number is deliberate: it's the figure most agencies and consultancies won't put in writing, and our whole Bring Your Own Software (BYOS) approach exists to remove the two things that kill speed and ownership — new-platform migration and bolted-on governance. The honest limit of this route is the flip side of its strength: an agency builds you a system, not a standing team. When the build is done, you own it, but you don't get three full-time engineers in the building. If you need that, you need to hire — which is exactly why many clients use an agency first and hire in-house later, around a system that already works.

AI agency vs in-house vs big consultancy: the comparison

Same goal — AI doing real work — three different products. Here is how they line up on what buyers actually decide on.

	In-house hire	Big consultancy	Specialist agency (KORIX)
What you're buying	Permanent capability	Strategy, process, cover	A shipped, owned system
Time to first production value	Slowest — hire, then build	Months — discovery first	21 days to a live use case
Cost (order of magnitude)	$150K–$250K+/yr per senior hire	Six to seven figures / program	$15K–$40K per engagement
Ownership at the end	Full — it's your staff & code	Varies; often platform/retainer-tied	You own code, models & docs
Governance & data	Yours to design	Robust, process-heavy	Governed from day one, data stays put
Best for	AI as permanent core	Enterprise-wide change + cover	One real system, live fast, owned

How to choose: place your own situation on the map

Forget the vendor pitches and answer four questions about your situation. One: how permanent is the need? If AI is core to your product for years, lean in-house. If you need a specific outcome, lean agency. Two: how fast do you need a working system? Weeks points to an agency; "we have time to do this properly across the org" points to a consultancy or in-house. Three: who needs to be convinced? If a board or regulator needs big-brand cover, a consultancy earns its fee; if you just need the thing to work, it doesn't. Four: do you have a software stack worth building on? If yes, an agency can build inside it immediately; if you're pre-systems, you need foundations before any agent. Your answers, not the salesperson's, decide the route.

The receipts: what the agency route looks like when it works

We hold ourselves to the production bar all three routes are judged against. Four of KORIX's last four projects reached production. Proteinverse — a 5-star Clutch engagement with founder Lucky Valecha — cut order-to-shipment time from 15–20 minutes to under 90 seconds and launched at a 91/100 mobile Lighthouse score. Numerology Matrix, a 5-star Clutch project for Anna Mazurowska, was live in production by day 18. A B2B lead-intelligence pilot shipped by day 21. And KORIX Brain — the governed AI operating system we run our own company on — is the dogfood proof. None of that required a standing team or a six-month discovery; it required the right route for a defined outcome.

When KORIX is the wrong choice — honestly

Say-what-others-won't time. A specialist agency is the wrong call in four clear cases. If AI is your permanent core product and you need engineers in the building every day, hire in-house — we'll help you scope the first system, but you should own the team. If you need formal big-brand cover for a board or a regulator, a top-tier consultancy buys something we can't. If you don't yet have a software stack worth building on, you need foundations first, not agents — we'll tell you that on the first call rather than sell you a build. And if what you actually want is a cheap monthly subscription, an off-the-shelf SaaS tool is the honest answer; our work is custom build, not a seat license. We'd rather lose a bad-fit project than ship one that should never have started.

The bottom line: there's no best route to AI — only the right route for your situation

Hire in-house when AI is your permanent core and you can wait two quarters to staff it. Use a big consultancy when you need political cover and board-level process more than a shipped system. Use a specialist agency when you want a governed, owned system live inside your existing stack in weeks, not a six-month discovery. The expensive mistake is matching the wrong route to your situation — not the route itself.

Shishir Mishra is Founder & Systems Architect (AI) at KORIX. 19 years building AI and enterprise systems across finance, healthcare, logistics, and real estate. KORIX deploys AI agents inside the tools your team already uses — not on top of yet another platform.

Originally published at korixinc.com

When NOT to Adopt AI: An Honest 2026 Guide

Shishir Mishra — Sun, 13 Sep 2026 07:44:07 +0000

Originally published at korixinc.com.

Don't adopt AI if you can't name one measurable problem it would solve, the process you'd automate is broken or undefined, your data is fragmented or ungoverned, you have no real software stack to build on, or you're only doing it because the board asked. In those cases AI amplifies the mess instead of fixing it. Adopting too early wastes more budget than waiting ever will — the smartest move is sometimes "not yet."

Almost everything written about enterprise AI is written to make you adopt it faster. This is the opposite. KORIX founder Shishir Mishra has spent nineteen years building and inheriting software, and the most expensive failures he sees aren't bad models — they're good tools adopted by organizations that weren't ready for them. A pilot greenlit because a competitor announced one. A "data project" with no defined question. An automation built on top of a process nobody had actually mapped. None of those fail because the AI is weak. They fail because the timing was wrong.

So this guide does the unfashionable thing: it tells you when to not buy — including from us. By the end you'll have seven concrete signals that mean "wait," a clear picture of who governed AI genuinely isn't for, and an honest test for whether your own organization is ready. If the answer is "not yet," that's not a failure — it's the cheapest, smartest decision you can make this quarter.

Why "too early" is the real AI failure mode

The headline numbers look like an adoption triumph and a deployment disaster at the same time. Stanford's 2025 AI Index found that 78% of organizations used AI in 2024. Yet MIT's NANDA initiative found only about 5% of custom enterprise AI pilots reach production with meaningful value — a figure corroborated in independent analysis of the 2025 data. And Gartner's estimate of generative-AI projects abandoned after proof-of-concept rose from at least 30% to at least 50% by the end of 2025.

Read those three numbers together and a pattern appears: a huge wave of organizations adopting AI, and the overwhelming majority getting nothing to production. The gap isn't a model-quality problem — the named causes are poor data, weak governance, escalating cost, and unclear value. Every one of those is a readiness problem, not a technology problem. They are what "adopted too early" looks like on a balance sheet. The short version is this: the failure usually happened at the decision to start, not during the build.

KORIX defines AI readiness as four preconditions — a defined use case, a stable process, governable data, and clear ownership. When all four are present, AI tends to ship. When two or more are missing, adopting AI doesn't fix the gap — it spends money discovering it. The rest of this article is the honest list of signals that you're missing them.

Seven signals you should NOT adopt AI (yet)

If any two of these describe you, the responsible move is to pause and fix the foundation before you spend a pound or a dollar on a build.

1. You can't name one measurable outcome. "We want to use AI" is not a project; "we want to cut order-to-shipment time from 20 minutes to under 2" is. If you can't state the single, measurable thing AI is supposed to change, there's nothing to scope, nothing to test against, and nothing to know whether it worked. Vague mandates are the most common reason a pilot drifts until a CFO quietly kills it.

2. The process you'd automate is broken or undefined. AI is a force multiplier — it multiplies whatever you point it at, including chaos. Automating a process nobody has actually mapped just makes the breakage faster and harder to spot. If your team can't draw the current process on a whiteboard and agree it's right, automate nothing yet. Map it, fix it manually until it's stable, then — and only then — consider automating the stable version.

3. Your data is fragmented, stale, or ungoverned. The model is rarely the problem; the data feeding it usually is. If your information is scattered across systems that don't talk to each other, or you can't answer "where does this data live and who can see it?", an AI build will stall the moment it meets a real security or compliance review. Data residency and access control are not afterthoughts — if they're unresolved, you're not ready.

4. You don't have a software stack worth building on. The fastest, most durable AI lives inside the tools a team already uses — the principle behind our Bring Your Own Software (BYOS) approach. If you're pre-systems — running the business on spreadsheets and inboxes with no real platform underneath — you need foundations first, not agents. Building AI on top of nothing means building the nothing first, which is a different (and earlier) project.

5. You're adopting for the board, not for a pain. "Everyone else is doing AI" is FOMO, not strategy. Adoption driven by an announcement, a competitor's press release, or a slide that needs an "AI" bullet tends to produce demos that impress in the room and die in production, because no real operational pain was ever anchoring the work. If the honest driver is optics rather than a problem, the honest answer is to wait until there's a problem.

6. You need it live next week. A demo is cheap and fast; production-grade reliability, monitoring, governance, and integration are neither. If your timeline is "by Friday," you're scoping a toy, not a system — and a toy in production is a liability. Real AI work runs in weeks, not a weekend. If the deadline can't move and the scope can't shrink to something genuinely small, don't start.

7. You want a $50 subscription, not a build. Sometimes the honest answer is a cheap off-the-shelf tool, and there's no shame in that. If your need is generic and a SaaS product already solves it well, buying a seat license is smarter than commissioning custom work. Custom, governed AI is worth it when the use case is specific to your business and the data has to stay in your systems — not when an existing tool would do.

When AI IS the right call

This isn't an argument against AI — it's an argument against adopting it blind. The flip side of the seven signals is a clear green light. AI is the right call when you can name one specific, measurable outcome; when the process behind it is defined and stable enough to automate; when your data lives in systems you can govern; and when you're willing to own the result rather than rent it forever. When those four line up, the same research that looks grim in aggregate flips in your favour — the organizations that ship are the ones that started ready. The discipline of governed AI implementation exists precisely to keep those four conditions intact from day one.

How to get ready — the path from "not yet" to "go"

"Not yet" is a plan, not a dead end. If the signals above describe you, here is the sequence that turns a no into a yes — and notably, none of the first three steps require buying any AI at all.

Step one: pick one measurable outcome. Not "adopt AI" — one number you want to move, owned by one person, with a baseline you can measure today. The narrower the better. A single shipped use case teaches you more than a sprawling strategy, and it gives every later decision something concrete to be judged against.

Step two: map and stabilise the process by hand. Before any automation, draw the current process end to end and fix it manually until it's boring and repeatable. This is unglamorous and it is where most of the real value hides — McKinsey's State of AI research repeatedly finds that the organizations capturing value from AI are the ones that redesigned the underlying workflow, not the ones that bolted a model onto an old one. A stable manual process is the thing AI then makes fast; an unstable one is the thing AI makes fast and wrong.

Step three: consolidate and govern the data. Get the relevant data into systems that talk to each other, and answer the two governance questions up front — where does it live, and who can see it. If you can't answer those, you're not ready to point a model at it. This step alone often surfaces problems worth fixing regardless of whether AI ever enters the picture.

Step four: decide ownership. Will you own the result — the code, the models, the documentation — or rent it forever from a vendor? Deciding this before you build keeps you out of the lock-in trap and shapes which delivery route makes sense. Once those four are in place, you've moved from the bottom of the decision matrix to the top, and the odds that you become part of the 5% that ships rise sharply.

Adopt now, fix first, or don't: a decision matrix

Map your honest answers against this. Most organizations are in the middle column — and the middle column's correct action is "fix the foundation," not "buy AI."

Your situation	Verdict	The honest next step
Clear use case · stable process · governable data · willing to own it	Adopt now	Scope one use case to a fixed, short production timeline
Real pain, but messy process or scattered data	Fix first, then adopt	Map and stabilise the process + consolidate data before any build
No defined use case · adopting for the board	Don't adopt yet	Find one measurable problem worth solving first
Pre-systems (no real software stack)	Don't adopt yet	Build the foundational systems before any agent
Generic need a SaaS tool already solves	Don't build	Buy the off-the-shelf subscription — it's the cheaper, honest answer

Who governed AI specifically isn't for

Even among companies that are technically "ready," governed, custom AI — the kind KORIX builds — isn't always the right shape. It isn't for teams who want a permanent in-house capability more than a shipped system; if AI is your core product for years, you should hire and own the team. It isn't for buyers who need a big-brand consultancy's process and cover for a board or regulator. And it isn't for anyone who wants AI without governing the data that feeds it — that's the one precondition we won't compromise on, because ungoverned AI is how the failures in this article happen. Naming who we're not for is not modesty; it's how you can trust what we say about who we are for.

The real cost of adopting too early

Waiting feels like falling behind. Adopting into chaos is far more expensive. When you start before you're ready, you pay to discover what you could have known for free: that the data wasn't clean, the process wasn't defined, or no one owned the outcome. The pilot stalls, the budget burns, and the organization draws the worst possible conclusion — "AI doesn't work for us" — when the real issue was timing. That false conclusion is the most expensive part, because it poisons the next, better-timed attempt and makes it harder to fund. A KORIX engagement runs $15,000–$40,000 when the conditions are right; spent before they're right, that same money buys a stalled pilot and a demoralised team. The cheapest project is the one you correctly chose not to start.

Picture the common version of this. A mid-market firm sees a competitor announce an "AI assistant," so the leadership team greenlights one of their own with a quarter's budget and a vague brief to "use AI in operations." There's no single metric, the order data lives in three disconnected systems, and the process it's meant to support has never been written down. Four months later there's an impressive demo that works in a sandbox and falls over the moment it touches real, messy data and a security review. The budget is gone, the team is deflated, and the lesson the board takes away is "AI isn't ready for us." Every expensive part of that story was avoidable — not by buying a better model, but by waiting until there was a defined outcome, clean data, and a mapped process. The technology was never the bottleneck.

Waiting is not the same as falling behind

The fear that powers premature adoption is that waiting means losing. It doesn't. The companies winning with AI aren't the ones who adopted earliest — they're the ones who adopted readiest. A competitor who shipped a flashy pilot that quietly died is not ahead of you; they're behind, with a burned budget and an organization newly sceptical of AI. Meanwhile the months you spend getting ready — defining the use case, fixing the process, governing the data — are not idle. They produce value on their own: a cleaner process and consolidated, governed data are assets whether or not AI ever arrives. So "wait" is rarely "do nothing." It's "do the foundational work that makes the eventual build succeed, and that pays off even if it doesn't." The genuinely behind companies are the ones who skip that work twice — once by adopting too early and failing, and again by having to rebuild trust before they can try properly. Patience, here, is a competitive advantage disguised as caution.

How we apply this — including turning work away

We hold ourselves to this on the first call. When a prospect fails the readiness test, we say so — even when they're ready to pay — because a stalled build costs them money and costs us a reference we'd never get. The projects that did ship were the ones that started ready: Proteinverse, a 5-star Clutch engagement with Lucky Valecha, began with a sharp, measurable goal (cut order-to-shipment time, which dropped from 15–20 minutes to under 90 seconds) and a real stack to build on. Numerology Matrix, a 5-star Clutch project for Anna Mazurowska, had one clear use case and shipped to production by day 18. In both cases the readiness came first and the AI came second — which is the whole point.

So before you greenlight anything, run the four-question readiness test on your own situation, and be honest about the answers. If they're clean, you're a strong candidate and the next step is scoping one use case to a real production timeline. If two or more are shaky, the smartest, cheapest decision you can make this quarter is to fix the foundation first — or to decide, with full confidence, that the answer for now is simply "not yet." Either way you'll have made the call on evidence instead of FOMO, which is more than most of the 95% can say.

The bottom line: the smartest AI decision is sometimes "not yet"

AI fails far more often from being adopted too early than from being adopted too late. If you don't have a real use case, a clean stack to build on, a process worth automating, and the will to govern the data, the honest move is to fix those first — or not adopt at all. Waiting costs you nothing; adopting into chaos costs you the budget and the credibility.

Shishir Mishra — Founder & Systems Architect (AI), KORIX. 19 years building AI and enterprise systems across finance, healthcare, logistics, and real estate. KORIX deploys AI agents inside the tools your team already uses — not on top of yet another platform.

Do You Need a Head of AI Governance? (2026)

Shishir Mishra — Sat, 12 Sep 2026 07:44:03 +0000

Probably not — not yet. Unless you are a bank, a regulated insurer, or a 1,000-plus-person enterprise, a dedicated Head of AI Governance is usually the wrong first move in 2026. The governance work is real and non-negotiable, but for most companies it belongs inside how you deploy AI — owners, logging, rollback, scope limits — not in a new six-figure executive who arrives after the agents are already live.

I have spent nineteen years inheriting other people's systems — the codebase nobody documented, the automation that worked until it quietly didn't. The pattern is always the same: the failure was never the technology. It was that nobody owned it, nobody logged what it did, and nobody could stop it cleanly when it went wrong. AI agents have taken that old failure mode and put it on a faster engine.

So when the headlines say every serious company is now hiring a Head of AI Governance, the operator's question isn't "should we keep up?" It's "what problem does that hire actually solve, and is a new executive the cheapest way to solve it?" This piece gives you the honest answer the recruiters and the vendor pages won't: who genuinely needs the role, who is buying governance theatre, and what to do instead if you're in the second group.

The hiring wave is real — here's what's behind it

The title is having a moment. The IBM Institute for Business Value 2026 CEO Study — a survey of 2,000 CEOs across 33 countries, released May 2026 — found a Chief AI Officer now sits at 76% of organisations, up from just 26% a year earlier, and governance is increasingly written into that remit. Real, datable appointments back it up: Lloyds Banking Group named Sameer Gupta its chief data and AI officer in 2026 with oversight and governance explicitly in scope, and the UK government created its first central Chief AI Officer role.

So what does the job actually involve? Day to day, a Head of AI Governance sets and enforces the rules for how AI gets built and shipped: who owns each system, what it is allowed to touch, how its decisions are logged, how a misbehaving model is rolled back, and how the company stays compliant. That function is genuinely necessary. The only real question is whether it needs a dedicated executive, or whether it can be engineered into how you deploy.

Underneath the hiring is a genuine fear, and it is well founded. The same companies that rushed agents into production are discovering the brakes were never installed. That is the actual driver — not a fashion, a fire.

The real question is the function, not the title

Here is the distinction almost no one makes. "Governance" is not a person — it is a set of properties a system either has or doesn't. KORIX defines governed AI as artificial intelligence deployed with ownership, logging, confidence thresholds, rollback, and scope limits built in from day one, so that every decision is traceable and reversible. A Head of AI Governance is one way to make those properties show up. Engineering them into the deployment is another — and for most companies, the cheaper one.

The trap is assuming the title creates the controls. It doesn't. A new executive cannot retroactively govern an agent that was shipped without a kill switch any more than a new CFO can audit books that were never kept. The control has to exist in the system. The leader, when you need one, manages controls that are already there.

KORIX founder Shishir Mishra, who has spent nineteen years rebuilding the inherited systems other people walked away from, puts it plainly: "A governance title without engineered controls is a smoke alarm with no battery — it looks like safety right up until the moment you actually need it. Govern the deployment first, and the org chart can wait." That is the whole argument in one line: the hire is a lagging indicator of governance, never the cause of it.

The data the people hiring for the title aren't reading

In a May 2026 analysis, Gartner predicts that by 2027, 40% of enterprises will demote or decommission their autonomous AI agents because of governance gaps discovered only after production incidents — and separately warns that 50% of AI agent failures will trace back to inadequate governance and interoperability (coverage via CIO, for a crawlable corroborating source). Notice what that says: the failures are showing up after deployment, in systems that were already live. A governance hire made today does not undo a guardrail that was skipped six months ago.

Shiva Varma, a Senior Director Analyst at Gartner, puts the root cause bluntly: "Enterprises are treating AI agent governance as binary, either locked down or fully trusted, and that is the root cause of failure." Governance isn't a switch you flip by filling a seat — it is a set of graded controls matched to each system's autonomy and blast radius.

And the maturity gap is stark. Deloitte's 2026 State of AI in the Enterprise — a survey of 3,235 business and IT leaders across 24 countries — found only 21% of organisations have a mature governance model for agentic AI, even as 74% expect to be using agents within two years. Most companies are scaling faster than their guardrails. A title on an org chart closes none of that gap on its own; engineered controls do.

Head of AI Governance vs governed deployment

For most companies the choice isn't "govern or don't." It is "buy the function as a senior hire, or build the function into how you ship." Here is the honest comparison, with the trade-offs the recruiters skip:

Dimension	Hire a Head of AI Governance	Embed governed deployment
Typical cost	$250,000+ a year, fully-loaded, plus a team	$15K–$40K one-time per deployment, controls built in
Time to real control	Months: hire, onboard, write policy, get buy-in	Weeks: guardrails ship with the system
What it actually changes	Adds a policy layer above existing systems	Puts ownership, logging, rollback inside each system
Best fit	Banks, regulated firms, 1,000+ headcount	SMB and mid-market deploying their first agents
Main risk	Governance theatre — a title without engineered controls	Needs disciplined deployment partners or in-house rigour

Neither column is wrong. They solve the same problem at different scales. The mistake is buying the left column when your situation calls for the right one — paying executive money for a policy layer over systems that still have no kill switch underneath.

Want a Realistic Plan for Your Project?

No sales pitch. We will give you an honest read on what your situation actually needs, what it should cost, and whether AI is even the right tool here.

Who actually needs the hire — and who is buying theatre

Let me say the part others won't. For a 60-person firm running two or three AI workflows, a dedicated Head of AI Governance is almost always premature. It is not the right fit, and the trade-off is real: you spend executive budget on someone whose first six months are policy documents while the underlying systems stay exactly as ungoverned as before. That is the red flag — governance that lives in a deck instead of in the code.

You genuinely need a dedicated leader only when the exposure is organisation-wide. Hire one when all three are true:

Regulated sector — banking, insurance, or healthcare, where an audit trail is a legal obligation, not a nice-to-have.
A fleet of autonomous agents touching customer or financial data — not one or two workflows, but many systems making consequential decisions.
Roughly 1,000+ people — large enough that no single team can see the whole AI footprint.

Meet all three and a leader stops being theatre and becomes necessary. Meet one or none and the honest trigger says wait: the driver should be regulation and headcount, not the fact that a competitor announced a hire on LinkedIn.

Regulation is the one external clock worth watching here. The EU AI Act's obligations for high-risk systems begin landing in 2026, with documentation, human-oversight, and risk-management duties that genuinely benefit from a single accountable owner. And it is not only Europe: the US NIST AI Risk Management Framework, the SEC's sharpening scrutiny of AI disclosures, and a growing patchwork of state laws all point the same direction. But notice what every one of them actually asks for: evidence that each system is logged, supervised, and controllable. If those properties are already engineered into your deployments, you can produce that evidence whether or not a Head of AI Governance sits above them. If they aren't, no title will conjure the audit trail after the fact. The regulation rewards the controls, not the org chart — which is exactly why building the function beats buying the title for everyone except the largest, most regulated players.

What to do instead, if you're not a bank

Make governance a property of deployment. For every AI system you run: name a single owner, log every decision it makes, give it a confidence threshold and a kill switch, limit what it can access, and put a review on the calendar. Done this way the controls arrive with the system, not after an incident — which is exactly the gap Gartner says is killing agents in production.

This is the work KORIX does: we deploy governed AI inside the software you already run for a fixed $15K–$40K — a one-time per-deployment fee, not a recurring salary — with ownership, logging, and rollback built in. These are the same controls a Head of AI Governance would eventually mandate, shipped from day one instead of legislated after the fact, and applied across your existing tools rather than as a rip-and-replace (our Bring Your Own Software approach). If you want the deeper background, start with what governed AI actually means, the difference between AI governance and governed AI, and the specific risks that go wrong when agents run ungoverned. You can always add the executive title later — once you are running enough autonomous AI that a full-time leader is justified, not as a substitute for controls you never built.

If you would rather see the controls in your own stack than read about them, that is the whole point of a 21-day AI pilot — governed, owned by you, live in three weeks. Book a free fit check and we will tell you honestly whether you need a governance hire, or just governed deployment.

You don't need a Head of AI Governance — you need governance baked into how you deploy.

The hiring wave is real, but for most companies the title is a lagging signal, not a control. A new executive cannot govern agents that were never built with guardrails in the first place. Put the function — ownership, logging, rollback, scope limits — into the deployment itself, and you get the governance without the six-figure hire. Add the role later, when scale and regulation actually demand it.

Originally published at korixinc.com.

GPT-6 Astra: What to Decide Before You Switch It On

Shishir Mishra — Fri, 11 Sep 2026 07:49:26 +0000

Originally published at korixinc.com.

GPT-6 Astra is disabled by default in ChatGPT Business and Enterprise. An owner must turn it on. It is worth enabling for most teams, but three things changed that your AI policy probably does not cover: it is the first OpenAI model at the Critical cybersecurity threshold, its reasoning is materially harder to inspect than the model you use today, and OpenAI published both of those facts itself.

Who this guide is for

The person in a regulated firm who owns the decision: an IT director, a compliance lead, a managing partner. No machine learning knowledge required. If you are choosing a model for an engineering team, the benchmark round-ups will serve you better than this will.

Three facts, not the benchmark table

The capability is not in dispute. In OpenAI's own announcement Astra saturates three of the hardest public benchmarks: 98% on FrontierMath Tier 4, 99.9% on ARC-AGI-3 and 100% on ExploitBench, plus 72.6% on OSWorld 2.0 computer use. Those matter to an engineer choosing a model. They are not what a compliance officer, an IT director or a managing partner has to decide. These three are.

1. It is off until an admin enables it

In Business and Enterprise workspaces, Astra is disabled by default. An owner enables it for the whole workspace or for specific roles, and Early Model Access does not carry it over. Doing nothing is a valid choice. It should be a recorded one rather than an accident.

2. It is the first model rated Critical for cyber capability

OpenAI's Preparedness Framework reserves Critical for capabilities that open a new pathway to severe harm. Astra is the first model it has placed there, which requires safeguards during development rather than only at release.

3. It is harder to monitor, by OpenAI's own testing

Astra reasons using recurrent depth, which does not expose a readable chain of thought. OpenAI reported a substantial decrease in chain-of-thought monitorability against previous models.

What you gain, and what you can no longer see

Until now, a reasoning model wrote down its working. That scratchpad was not a nicety. It was the practical mechanism by which a human, a red team, or an automated monitor could look at a model's output and ask how did it get here. It is the closest thing the industry has had to an audit trail on a model's judgement.

Astra reasons differently. Its recurrent-depth approach loops internally before producing an answer, and that loop is not rendered as readable text. The capability gain is real, and so is the trade-off: you are getting a better model and a less inspectable one in the same release.

That trade-off is worth naming plainly, because it decides who this guide is for. If a person reads every output before it does anything, the downside barely touches you. If you were planning to let the model act on its own against a customer record, this is not the release to start with.

OpenAI put it plainly in its own disclosure: Astra's written reasoning is harder to monitor than the model it replaces. We looked for a figure putting a number on that gap and could not source one to OpenAI, so this piece does not carry one. The direction is what matters, and OpenAI has stated the direction itself.

"CoT monitoring is a core part of our misalignment safety strategy that has no good substitute now." — Tomek Korbak, alignment researcher at OpenAI, quoted in TechRadar

"Progress in intelligence does not guarantee progress in alignment." — Jakub Pachocki, chief scientist at OpenAI, quoted in Vellum

Both come from inside the company that built it, published alongside the release rather than dragged out of it. That candour is exactly what makes the model possible to plan around.

Critical is a word with a published definition

Critical is not marketing language. In OpenAI's Preparedness Framework it is a defined threshold, and the definition is worth reading slowly: a model reaches it if it can identify and develop functional zero-day exploits of all severity levels in many hardened real-world systems without human intervention, or devise and execute novel end-to-end cyberattack strategies against hardened targets given only a high-level goal.

The framework separates High capability, which amplifies an existing route to serious harm, from Critical, which opens a route that did not previously exist. Critical requires safeguards during development, regardless of whether the model is ever deployed. Astra is the first model OpenAI has placed in that band, and the cyber-sensitive capabilities are gated behind a restricted access programme OpenAI calls Daybreak, rather than shipped to everyone.

Two honest readings of that follow, and you should hold both. The first: OpenAI classified its own model at its most serious tier and restricted it, which is the framework doing its job in public. The second: your firm is now deciding whether to enable a tool its maker has described in those terms, and your AI policy was almost certainly written before that sentence existed.

Who should enable it, and who should wait

There is no universal answer here and anyone giving you one is selling something. The useful question is not "is Astra safe" but can we evidence what it did, and can we undo it. That splits cleanly by what the model is allowed to touch.

If the work is	Enable it?	Because
Drafting, research, summarising, internal analysis	Yes, with logging	A human reads the output before it does anything. Opaque reasoning matters far less when a person is the last step.
Coding and engineering work	Yes, in a reviewed pipeline	Code review is already your inspection layer. You are reviewing the artefact, not the reasoning.
Anything that writes to a system of record	Only with an audit trail and a reversal path	If you cannot read the reasoning, the log of actions becomes your only evidence.
Anything that touches a customer outcome unsupervised	Not yet	Under Consumer Duty and similar regimes you must evidence why a customer was treated a certain way. "The model decided" is not evidence.
Security testing or offensive tooling	Separate decision entirely	These are the capabilities OpenAI gated behind Daybreak. Treat it as a procurement and legal question, not an IT toggle.

It is worth being precise about the standard we are applying, because "governed" gets used loosely. KORIX defines governed AI as a system whose every action is logged against a named accountable human, scoped to what it may touch, and reversible without a rebuild. Those three properties are what let a firm answer a regulator, an auditor or an angry client after the fact. None of them depend on being able to read the model's reasoning, which is precisely why they matter more now than they did last month.

Notice that the first two rows are a straightforward yes. The concern is not the model. It is the gap between what it can do unsupervised and what you can prove afterwards. That gap is exactly what governed AI exists to close, and it just got wider by default.

Five things to settle before you enable it

None of these require a project. They require a named person and an afternoon.

Name the owner. One person decides whether Astra is on, for which roles, and reviews that quarterly. If nobody owns the toggle, the answer to "who approved this" is nobody.
Check the toggle rather than assume it. Astra is off by default and Early Model Access does not carry over, so your workspace state may not be what you think. Look at it.
Decide what it may write to. Reading and drafting is one risk profile. Writing to your system of record is another. Put that line in writing before someone discovers it by accident.
Make the action log the audit trail. You can no longer lean on readable reasoning, so what the model did has to be logged completely, with timestamps and a named accountable human, in a system you already trust.
Write down the reversal path. For every action it can take, know how to undo it and who can. If an action cannot be undone, it should not be automated yet, whatever the model scores.

If your staff are already using AI outside sanctioned tools, settle that first. A model policy nobody follows is not a control, and shadow AI does not wait for a rollout plan.

What we are doing with it, and where we are not

KORIX is an OpenAI Select Partner, which is why we read a release like this closely and why our first instinct is to help clients adopt it rather than avoid it. It does not mean we speak for OpenAI: everything above is their published material and our own reading of it. We have also said publicly that roughly 60% of our production AI runs on OpenAI and the other 40% deliberately does not. That split has never been about loyalty. It is about which workloads we are willing to put behind a single vendor's judgement.

Astra has not changed that ratio and we are not going to pretend it did in the first week. We are using it where a human reads the output before anything happens, which is most of our engineering and research work, and the speed gain there is real. We are not putting it behind an unsupervised action on a client's system of record until we can evidence what it did as well as we could with the previous model. Not because we think it is dangerous, but because the honest answer to "show me why it did that" got harder this month.

The bottom line

GPT-6 Astra is a genuine capability step and most firms should enable it for work where a person reads the output. The decision that deserves an hour of your time is narrower: anywhere the model acts without a human in the loop, your action log has just become the only evidence you have.

If that log is complete, timestamped, and owned by a named person, this release is good news for you. If it is not, the right move is not to block the model. It is to fix the log first, then switch it on.

Originally published at https://korixinc.com/learning-center/gpt-6-astra

What Is an AI Agent? A Builder's Definition (2026)

Shishir Mishra — Sat, 05 Sep 2026 07:43:18 +0000

An AI agent is software you hand a goal, not a task. It reads the situation, decides the next step on its own, takes the action, and adjusts when the result changes, with little or no step-by-step instruction. A chatbot only answers. An automation only follows the fixed rules you wrote in advance. An agent decides and acts. That one difference changes what it can do, how it breaks, and what it costs.

We build and run AI agents in production, including for clients like Proteinverse. So this is the definition from the inside, not from a launch deck.

The word "agent" is now stamped on almost every AI product. Most of it is a chatbot with a nicer name, or a workflow with a chat box bolted on. That matters. The three behave differently, break differently, and cost differently. Buy the wrong one and you either overpay for autonomy you cannot control, or you underbuy and wonder why your "agent" cannot handle anything you did not script.

This guide gives you the builder's definition, the one distinction that decides which tool you need, what agents do well today, and an honest read on when not to build one. By the end you will look at any "AI agent" pitch and know what you are really being sold.

What is an AI agent?

KORIX defines an AI agent as software you delegate an outcome to, not a task. You give it a goal. It works out the steps itself, using the tools and systems it can reach, until the goal is met or it hits a limit you set. The point is not the model or the chat box. It is agency: the software picks its own next move.

This is a real shift, not marketing. Andrew Ng, founder of DeepLearning.AI and former head of Google Brain, argues that agentic workflows, where an AI plans, acts, and revises across many steps, will drive more of the next wave of progress than bigger models alone. Andrej Karpathy, a founding member of OpenAI and former head of AI at Tesla, calls the large language model a new kind of operating system, with agents as the programs that run on it and act in the world. The market agrees. Gartner predicts that by 2028, 33% of enterprise software applications will include agentic AI, up from less than 1% in 2024.

The anatomy of an AI agent: perceive, reason, act, remember

Strip the branding and every real agent runs one loop, four parts:

Perceive: it reads the goal and the current state, a ticket, a document, a database row, the result of its last move.
Reason: it decides what to do next. It chooses from the actions open to it, instead of following a fixed script.
Act: it uses tools. It calls an API, updates a record, sends an email. This is the part a chatbot does not have.
Remember: it holds context across steps, so step four knows what happened in steps one to three.

The loop is the whole point. A chatbot runs once and stops. An agent runs the loop again and again until the goal is met or it hits a wall. Take away the acting and you have a chatbot. Take away the deciding and you have an automation.

AI agent vs chatbot vs automation: the difference that matters

This is the distinction that decides which tool your job needs. These are not three points on one scale. They are three different kinds of software.

Property	Chatbot	Automation (Zapier, Make, n8n)	AI agent
What it does	Answers a message	Runs a fixed path you wrote	Pursues a goal, choosing steps itself
Who decides the steps	You, one message at a time	You, in advance	The software, at runtime
Acts on other systems	Rarely	Yes, but only as scripted	Yes, and it chooses which action
Handles unplanned cases	No	No	Yes
Predictability	High	Very high	Lower, needs guardrails
Best for	Q&A, FAQ, deflection	Fixed, repeatable pipelines	Decision-heavy, variable work

The honest read: autonomy is not free. The same thing that lets an agent handle a case you never scripted also lets it take an action you never intended. That is why a real agent needs governing.

What an AI agent can actually do today

The wins that hold up in 2026 are narrow and bounded, not general. An agent earns its place when the job is repetitive, decision-heavy, and easy to measure. The patterns we see work in production:

Support resolution: it reads the ticket, checks the order in your system, takes the routine action (a refund, a reschedule, a status update), and escalates the rest to a person.
Document processing: it pulls the fields from invoices, claims, or contracts, files them correctly, and routes the exceptions a human needs to see.
Lead qualification: it enriches an inbound lead, scores it against your rules, and books or routes it, so your team only touches the ones worth their time.
Reconciliation: it compares two systems that never agreed and flags the mismatches with the evidence attached.

The failure pattern is the opposite: a vague "AI assistant that does everything." Vagueness is why most pilots stall. MIT's NANDA research found that roughly 95% of enterprise generative-AI pilots deliver no measurable business return. The gap is rarely the model. It is the missing system around it: no clear job, no data access, no plan for the cases the model gets wrong.

What separates a production agent from a demo

A demo agent works once, on a clean input, in front of an audience. A production agent runs unattended against messy reality. The difference is governance, not intelligence. This is where most 2026 projects die. Gartner expects more than 40% of agentic AI projects to be scrapped by the end of 2027, mostly because teams shipped autonomy with no controls to run it safely.

Four controls make an agent safe enough to trust with real work:

Observability: every decision and action is logged, so you can see what it did, why, and prove it later.
Least-privilege access: it can reach only the systems and actions the job truly needs. Nothing more.
Human-in-the-loop: anything costly or hard to reverse waits for a person to approve it.
A named owner: one accountable human, not "the AI," answers for what it does.

Shishir Mishra, KORIX founder, puts it plainly: "An ungoverned agent is a fast worker with no supervisor. It will do what it infers you want, at scale, including the things you did not intend. The controls are not paperwork. They are the difference between an agent you can run on Monday and one you have to switch off by Friday."

Do you need an AI agent? Often, not yet

Here is the part most vendors skip. An agent is the right tool for one shape of problem, and the wrong tool for many others. An agent is not for you if any of these is true:

The task is rare or one-off. The build cost never pays back.
A fixed automation already handles it well. Do not add autonomy you then have to govern.
A wrong action would be costly and hard to reverse, and you are not ready to put controls around it.
You cannot yet say what success and failure look like. With no definition of done, an agent cannot know when to stop.

The downside of agents is real. They are less predictable than the automation they often replace. They need monitoring and maintenance. And the red flag on any pitch is a vendor who talks about the demo and not about what happens when the agent is wrong. Before you buy, ask four questions. How will I see what it did, and why? What can it not touch? What happens when it gets something wrong? Who owns its behaviour? A vendor who cannot answer all four is selling you a demo. Deloitte expects roughly 25% of companies already using generative AI to run agentic pilots in 2025, rising toward 50% by 2027. The ones that succeed almost always start narrow.

What an AI agent costs

Cost is the question vendors dodge, so here it is straight. A production agent build with KORIX runs 15,000 to 40,000 USD, depending on scope and how many of your systems it touches. Runtime is the cheapest line, often around 100 USD a month for a simple agent, more for complex, high-volume ones. The build is the big number. Maintenance is the line most people underestimate. Runtime is the smallest.

The bottom line

An AI agent does not just answer, it decides and acts toward a goal, and that is exactly why it needs governing.

Chatbots reply. Automations follow fixed steps you wrote. An agent chooses the steps itself to reach an outcome. That autonomy is the value and the risk, which is why a production agent needs observability, hard limits, and a human owner from the first day it runs.

Originally published at korixinc.com.

The Compliance Admin Crushing UK Letting Agents

Shishir Mishra — Fri, 04 Sep 2026 07:46:55 +0000

Originally published at korixinc.com.

A letting agent isn't in the property business. They're in the deadline business. Every tenancy carries a stack of legal safety checks, each with its own clock and its own five-figure penalty: gas safety (up to £6,000), electrical checks (up to £40,000), deposit protection within 30 days (one to three times the deposit), and Right to Rent (up to £10,000 per occupier). Miss one and it's not admin anymore. It's a fine.

I'm Shishir Mishra, and I meet a lot of agents who are quietly drowning, and it's almost never the lettings that's hard, it's the compliance. Professional agents manage a huge share of England's 4.7-million-household private rented sector, plus millions of leasehold flats, and every one of those homes carries the same non-negotiable calendar of certificates and deadlines. When a portfolio grows faster than the admin behind it, something slips. And in this sector, "something slips" has a statutory price tag.

This article puts the real load on paper — the official deadlines and penalties, where the time and money actually leak, and the three ways agents run the compliance-and-chasing job. Only one of them is safe in a sector whose entire value is evidencing that you did the right thing on time.

The deadline maze every agent has to track

This is the part outsiders underestimate. For each tenancy and block, an agent is on the hook for a rolling set of legal requirements, each with an official penalty for missing it:

Requirement	Clock	Penalty for missing (official maximum)
Gas safety check + CP12 to tenant	Annual; cert within 28 days	Up to £6,000 per breach (HSE); unlimited fine on conviction
Electrical safety (EICR)	At least every 5 years	Up to £40,000 (raised from £30,000, Nov 2025)
Deposit protection + prescribed info	Within 30 days	1–3× the deposit, by court order
Right to Rent checks	Per occupier	Up to £10,000 (£20,000 repeat)
Fire risk assessment (block communal areas)	Ongoing, recorded	Fire-safety enforcement action

None of these are optional, and none forgive a busy week. The HSE sets the gas-safety maximum at up to £6,000 per breach, with an unlimited fine and up to six months' imprisonment on conviction; electrical (EICR) breaches now carry up to £40,000 under gov.uk regulations, raised from £30,000 in November 2025. This is exactly why, in one industry survey, 29% of landlords now name compliance as the main reason they use an agent at all — the value you sell is not missing these.

And the rules just got heavier

The Renters' Rights Act 2025 adds a new layer: landlords and every property must register on a new Private Rented Sector Database (regional rollout from late 2026), a Decent Homes Standard applies to the private rented sector for the first time, and a mandatory PRS Landlord Ombudsman is coming. Every one of those is more to track, evidence and keep current, on top of the calendar above.

The professional bodies see the same pressure. Timothy Douglas, Head of Policy and Campaigns at Propertymark, puts the sector's case plainly: "Our members work hard every day to provide safe, well-managed homes. We need mandatory regulation to ensure everyone in the sector meets the same high standards." Higher standards mean more evidence, and evidence is exactly what a stretched back office struggles to produce on demand.

Enforcement is sharpening at the same time. Local authorities can keep the civil penalties they levy for compliance breaches, which gives councils a direct incentive to check — and, with the electrical maximum now at £40,000, a single missed report is worth pursuing. So the risk isn't just theoretical exposure on a spreadsheet; it's a better-resourced enforcement side actively looking for the certificate you didn't get to. For a growing agency, the question stops being "will anyone notice?" and becomes "can we prove, on demand, that every deadline was met?"

Where the time and money actually leak

Two places, on top of compliance itself:

Arrears. In industry data, 17% of tenancies ended with more than five weeks' rent unpaid, and the average arrears claim rose 27% year on year to £1,816. Chasing arrears reliably is the difference between a phone call and a court claim.
Maintenance. When repairs drag, tenants notice — in the official English Housing Survey, 35% of renters who were unhappy with repairs blamed the landlord being slow to act. Slow maintenance triage is a retention and reputation cost, not just an admin one.

And the admin itself is spilling into people's lives. In one 2026 industry survey, 46% of agents said they regularly do admin in the evenings and 25% at weekends — roughly eight hours a week lost to tasks that could be automated. Another survey found 55% of property professionals never use PropTech at all, and half feel the available tools don't fix their real daily problems. The sector is under-digitised precisely where the risk is highest. (These are survey figures, not official statistics, but the direction of travel is hard to miss.)

The pattern will feel familiar if you've read the companion piece on insurance broker renewal leakage: in both trades, the money doesn't leak on the deal. It leaks on the follow-up nobody had time for.

Three ways to run the compliance-and-chasing load

Most agencies are doing one of these three things. They cost very differently — not in software price, but in fines risked and hours lost.

Cost line	Manual (spreadsheets + reminders)	Generic AI tool	Governed AI agent
Deadline coverage	Relies on memory, things slip	Partial, unsupervised	Complete, every certificate + deadline
Handler time	High	Medium	Low
Judgement on exceptions	Human, but stretched	Automated, opaque	Human-in-the-loop by design
Audit trail (evidence you complied)	Patchy	Weak / black-box	Full, timestamped, defensible
Risk when something's missed	Five-figure fine	Missed and no clear record	Flagged early, logged either way
Time to live	—	Weeks to months	~2 weeks

Why a governed agent, not a generic tool

That audit trail matters more in lettings than in most sectors. When a tenant, a council, or a redress scheme asks who checked what and when, a governed agent shows the timestamped record instead of a scramble through inboxes. A generic reminder tool logs that it pinged you; it cannot prove the obligation was actually met, by whom, and against which property.

In a sector where the whole job is evidencing that you did the right thing on time, an opaque tool that quietly acts on your book is the wrong answer. KORIX defines a governed compliance agent as one that runs the deadline calendar and the chasing inside the systems you already use, escalates every judgement call to a person, and logs each action so the evidence exists before anyone asks for it. In practice that means a governed agent that plugs into your existing stack (Reapit, Fixflo, Arthur), watches the compliance calendar and the maintenance and arrears chasing, and escalates the exceptions — so when a landlord, tenant or regulator asks "was this done?", the answer is one timestamped record away.

That's the difference between automation that optimises for "did it send" and governance that optimises for "can you prove it, and did a human decide the close calls."

Who this isn't for: if your compliance admin is already tight — every certificate tracked, every deadline hit, every action recorded — you don't have a leakage problem and you don't need an agent. Buy nothing. This is for agencies whose portfolio has outgrown the back office, where a missed EICR or gas cert is a matter of when, not if, and nobody can currently say how exposed they are.

How to size your own exposure

Count the recurring deadlines per unit — gas, electrical, EPC, deposit, Right to Rent, and per-block fire risk assessments — then multiply by your portfolio. That's your monthly deadline volume, and it's usually bigger than anyone guesses.
Ask who owns each one, and what happens when they're off sick. Key-person risk is the quiet danger — the calendar that lives in one person's head.
Add the arrears and maintenance chases you don't get to. Those are lost money and lost tenants, not just lost hours.
Cost the fix against the exposure, not the software. One missed EICR or gas cert can dwarf a year of getting the chase right. If reliable tracking prevents even one five-figure penalty, the comparison isn't close — and if your admin is already watertight, the honest answer is to leave it alone.

Run those four lines and you'll have a defensible figure for what your compliance load is really costing you, in fines risked and hours lost, and a clear read on whether governing the calendar is worth it. Either way, you'll be deciding on numbers instead of a feeling.

A note on the numbers: the penalty figures above are official maximums; the arrears, admin-hours and PropTech-adoption numbers are industry surveys, flagged as such; and any per-portfolio £ arithmetic you build from them is illustrative — re-run it with your agency's real deadline volume before acting.

The bottom line

Agents don't get fined for bad lettings. They get fined for missed deadlines. Fix the calendar, not the software.

Gas, electrical, deposit, Right to Rent and fire-safety checks each carry their own clock and their own five-figure penalty, and the Renters' Rights Act adds more to track and evidence. The reliable fix isn't another portal or a six-month project. It's a governed agent that runs the compliance calendar and the chasing, keeps a human on the judgement calls, and logs everything so you can always prove you complied. Size your exposure from real deadline volume, then fix the chase, not the software.

Shishir Mishra — Founder & Systems Architect (AI), KORIX. 19 years building AI and enterprise systems across finance, healthcare, logistics, and real estate. KORIX deploys AI agents inside the tools your team already uses — not on top of yet another platform.

What Unchased Renewals Cost UK Insurance Brokers

Shishir Mishra — Fri, 04 Sep 2026 07:43:38 +0000

Originally published at korixinc.com.

Here's the number most brokers never put on paper: even the best-retaining channel in UK insurance still loses about one policy in seven every year, and a large share of that isn't price, it's renewals nobody chased in time. For a mid-sized broker, three avoidable lapses a month is roughly £5,400 of commission this year and about £34,000 over the client lifetime.

I'm Shishir Mishra, and I keep meeting brokers whose renewal list lives in three people's heads and a spreadsheet. That isn't a system. It's a risk, and it's quietly expensive. According to BIBA, general insurance brokers arrange 94% of all commercial insurance business in the UK, so the whole model runs on renewals holding. Yet when a book grows faster than the admin behind it, non-responders don't get chased in time and policies lapse silently. Nobody decided to lose them; they just fell through the gap between "we'll get to it" and the renewal date.

This article puts a real number on that leakage, shows the three ways brokers actually run the renewal chase, and explains why only one of them is safe under Consumer Duty. The fix isn't another portal or a six-month IT project. A governed Renewal Agent chases renewals and claims status inside the systems you already run, live in 21 days, and you own it. It's making the chase happen every time, with a human on the judgement calls and a full audit trail.

Why renewals lapse (and it usually isn't price)

Retention rarely fails because a client shopped around and found something cheaper. It fails because the renewal conversation never happened. Three facts are worth holding together:

Brokers are the best-retaining channel and still lose roughly one in seven policies a year. The advised broker channel out-retains direct and price-comparison buying, yet even so a meaningful slice of the book leaves every year. If you keep around 85% of policies, you are losing about one in seven, and most brokers have never counted which of those were winnable.
Most of that loss is silence, not price. Industry retention analysis is blunt about it: renewals are frequently lost not because of price, but because the firm never had the renewal conversation at all. A timely, proactive contact, before the client has drifted or been re-marketed to, usually keeps them.
The admin is a second full-time job. Renewal management lives in spreadsheets, calendars and handlers' memory. When volume rises, the people who don't reply on the first attempt are exactly the ones who slip, because chasing a non-responder is precisely the low-urgency task that gets bumped by whatever is on fire today.

None of this is a competence problem. Good handlers chase the renewals in front of them. The leak is structural: there is no reliable mechanism that guarantees every non-responder gets a second and third touch, on time, without someone remembering to make it happen.

What renewal leakage actually costs

Put the maths on a single client. Take a £1,000 average SME commercial premium at roughly 15% commission. That's about £150 of commission per policy per year. A retained client renews for six or seven years, so each avoidable lapse forfeits roughly £900–£1,050 of future commission. Now scale it across a book:

Avoidable lapses per month	Commission lost this year	Lifetime commission forgone
3	~£5,400	~£34,000
5	~£9,000	~£57,000

For a broker on around £1m of commissions, that lines up with the high-single-digit "recoverable leakage" many operators cite, tens of thousands a year, most of it from clients who would have stayed if simply contacted in time. And the margin you're protecting is thinner than it looks: BIBA puts the cost of regulation at 5.2% of premiums, so every renewal you keep is defending a number that's already smaller than the headline premium suggests.

Two honest caveats. First, these figures are worked illustrations on typical numbers, not audited averages — the point is the shape of the loss, and you should re-run it on your own premiums, commission rate and tenure. Second, not all of it is recoverable: some clients genuinely leave on price or because they've closed. The recoverable part is the admin-driven silence, and that's the part worth building for.

Three ways to run the renewal chase

Most brokers are doing one of these three things. They cost very differently, not in software price, but in leaked commission and compliance risk.

Cost line	Manual (spreadsheet + memory)	Generic AI tool	Governed AI agent
Chase coverage	Inconsistent, non-responders slip	Partial, unsupervised	Complete, every renewal, every touch
Handler time	High	Medium	Low
Judgement on complex cases	Human, but stretched	Automated, opaque	Human-in-the-loop by design
Audit trail (Consumer Duty)	Patchy	Weak / black-box	Full, traceable
Compliance risk	Key-person risk	"The model decided", a red flag	Logged and defensible
Time to live	—	Weeks to months	~2 weeks

The manual approach isn't wrong. It's just capped by human attention, and it's the non-responders that fall out of the cap. A generic AI tool looks like the upgrade, but it introduces a new problem we'll come to next.

Why a governed agent, not a generic AI tool

This is the part where most "AI for brokers" pitches quietly fail. The FCA's approach to AI isn't a new rulebook. It's the existing one, applied. As the FCA's Chief Data, Information and Intelligence Officer Jessica Rusu has put it, firms "are still required to meet their commitments no matter how they choose to deliver their services." "The model decided" is not a defence. Under Consumer Duty you have to show you acted in the customer's interest, which means the renewal conversation, and the record of it, has to exist and be evidenced.

This isn't hypothetical pressure. Deloitte's Consumer Duty benchmarking of the general insurance market found 85% of firms increased governance around customer outcomes. Yet only 41% of brokers added the resource to deliver it, Deloitte found, and that gap between rising expectation and flat capacity is exactly where renewals slip.

So the safe setup isn't a black-box tool that quietly acts on your book. KORIX defines governed renewal chasing as an AI agent that runs every renewal touch inside your existing broking platform, escalates the judgement calls to a human, and logs every action for Consumer Duty. That's a governed agent: it runs the whole renewal chase inside the systems you already use, escalates the judgement calls to a person, and logs every action so the renewal conversation always happens and can be evidenced. A generic tool optimises for "did it send", a governed agent optimises for "can you prove it did the right thing, and did a human decide the close calls." That's retention and Consumer Duty in one move, rather than a retention gain that creates a compliance liability.

Concretely, that means the agent watches the renewal pipeline, contacts non-responders on a reliable cadence, drafts the follow-ups, and hands anything material — a mid-term change, a claim in the period, a client who wants to negotiate — to a handler with the context already assembled. It doesn't replace the broker's judgement; it removes the reason judgement never got applied. And because it sits inside the broker's existing platform (for example Acturis or Applied Epic) rather than on top of it, there's no data migration and no second system for the team to learn. That's what makes ~2 weeks to live realistic.

Who this isn't for: if your renewal admin is already fully covered, every non-responder chased on time, every touch logged — you don't have a leakage problem and you don't need an agent. Buy nothing. This is for brokers whose book has outgrown the people behind it, where the losses are silent and nobody can currently say how big they are.

How to size your own renewal leakage

A quick framework before you spend anything, the same one we'd walk through in a first call, and the honest way to decide whether a fix is even worth it:

Count the silent lapses. How many renewals a month currently get no second contact once the client doesn't respond first time? That number, not your headline retention rate, is the leak.
Put your own commission on it. Average premium × your commission rate × the number of silent lapses, then multiply by typical client tenure for the lifetime figure. Use your numbers, not ours.
Separate price losses from admin losses. Only the admin-driven lapses are recoverable by chasing better. Be honest about the split; inflating it just wastes your own time.
Cost the fix against the leak, not against software. If reliable chasing recovers even three renewals a month, compare that to what a fix costs — the leak is almost always the bigger number. If it isn't, don't build.

Run those four lines and you'll have a defensible figure for what unchased renewals are actually costing you, and a clear read on whether governing the chase is worth it, or whether your admin is already tight enough that the honest answer is "leave it alone." Either way, you'll be deciding on numbers instead of a feeling.

Sources and method: broker market share (94% of commercial insurance) and the cost of regulation (5.2% of premiums) draw on BIBA data; the FCA's position on AI accountability under Consumer Duty is set out by the FCA (Jessica Rusu); broker readiness figures come from Deloitte's Consumer Duty analysis; typical UK SME premiums are informed by public market data such as money.co.uk. Commission percentages, handler-hours, client-tenure and lifetime figures are industry estimates and worked illustrations, not audited averages — re-run them with a firm's real numbers before acting.

The bottom line

Most renewal loss isn't price. It's the chase that didn't happen. Fix the chase, not the software.

Even the best-retaining brokers lose about one policy in seven a year, and for a mid-sized firm a handful of unchased renewals a month is tens of thousands in lifetime commission walking out the door. The fix isn't a new portal or a six-month project. It's making the chase happen every time, with a human on the judgement calls and a full audit trail for Consumer Duty. Size your own leakage from real numbers, then fix the chase, not the software.

AI Agents vs Zapier, Make & n8n: 2026 Guide

Shishir Mishra — Fri, 28 Aug 2026 07:42:18 +0000

Use Zapier, Make or n8n when the task is a fixed set of rules: when X happens, do Y. Build an AI agent only when the work needs judgment under ambiguity: reading messy input, weighing options, and deciding what to do next. Workflows connect; agents decide. Most "we need AI" requests are really "we need automation," and paying agent prices for workflow problems is how budgets disappear.

Half the "AI agent" projects KORIX founder Shishir Mishra gets asked about don't need an agent at all; they need a Zapier zap and an afternoon. After nineteen years building software, the most common (and most expensive) confusion he sees is treating "automation" and "AI agent" as the same purchase. They aren't. One executes rules you already know; the other makes decisions you can't fully script. Buy the wrong one and you either overpay enormously for plumbing, or you try to force a rules engine to handle judgment it was never built for.

This guide draws the line clearly: what Zapier, Make and n8n actually do, what an AI agent actually does, an honest comparison of cost and fit, and (the part most vendors skip) exactly when you should not build an agent and just use a workflow tool instead.

The core distinction: connect vs decide

KORIX defines the difference simply: a workflow automates a path you already know; an agent decides a path you don't. Zapier, Make and n8n are workflow automation tools: you draw the steps in advance (trigger → action → action), and the tool executes that exact sequence every time, reliably and identically. An AI agent is given a goal and the freedom to choose its steps: it reads input that may be messy or unexpected, reasons about it, and decides what to do, which is powerful precisely because it isn't pre-scripted.

That single difference — predetermined execution vs. runtime decision — drives everything else: cost, reliability, and when each is the right tool. It's also why so much enterprise "AI" disappoints. Stanford's 2025 AI Index found that 78% of organizations used AI in 2024. Yet MIT's NANDA initiative found only about 5% of custom AI pilots reach production with real value. And Gartner expects 30% to 50% of generative-AI projects to be abandoned after proof-of-concept. A meaningful slice of those were agents built where a workflow would have shipped.

What Zapier, Make and n8n are great at

Workflow tools are excellent for the right job. Zapier is the most polished and beginner-friendly, with thousands of app integrations. Make (formerly Integromat) offers more visual, branching control at lower cost. n8n is open-source and self-hostable, which appeals to teams that want data to stay in their own environment and to avoid per-task pricing.

All three shine when the work is deterministic: move a new lead from a form into your CRM and Slack; sync invoices between two systems; send a templated follow-up on a schedule. The steps are known, the same input should always produce the same output, and you want it cheap and bulletproof. For that, you do not need (and should not pay for) an AI agent. A workflow tool will do it for a fraction of the cost, with predictability as a feature, not a risk.

What an AI agent is actually for

An agent earns its cost when the task can't be fully scripted. It's the right tool when input is ambiguous (free-text that doesn't fit neat categories), when the right action depends on judgment (which of many responses fits this unusual case?), or when exceptions arrive that no rule anticipated. An agent reads the situation, reasons, and decides, and can handle the long tail of cases a rules engine would choke on.

A concrete example: routing inbound support messages. If every message neatly carried a category, a workflow could route it in one rule. In reality messages are free-text, vague, and often span several issues at once, so deciding where each one should go is a judgment call, and that's where an agent earns its keep. The trade-off is non-determinism: an agent may choose differently on similar inputs, which is a strength for judgment work and a liability for plumbing.

How to tell which one you need: a 30-second test

Before you price an agent, run the task through four questions. They sort almost every case cleanly.

Can you write the whole rule down? If you can describe the task completely as "when this happens, do exactly that," with no "it depends," it's a workflow. The moment you find yourself writing "it depends on…", you've found the part that might need an agent.
Should the same input always produce the same output? If yes, you want the determinism of a workflow; an agent's freedom to choose differently is a bug here, not a feature.
Is the input structured or messy? Clean fields and predictable formats suit a workflow; free-text, edge cases, and exceptions that rules can't anticipate are agent territory.
How often do real exceptions occur? If 95% of cases follow the rule and 5% are oddballs, the elegant answer is usually a workflow for the 95% that calls an agent only for the 5%, not an agent for everything.

This mirrors what McKinsey's State of AI research keeps finding: the value comes from redesigning the workflow around the few decisions that actually matter, not from sprinkling AI across steps that were never decisions in the first place. Most teams discover, doing this honestly, that the majority of what they wanted an "AI agent" for is really deterministic plumbing — and that's good news, because plumbing is cheap.

AI agents vs workflow automation: the comparison

Same ambition (less manual work), two different tools. Here's how they line up.

	Zapier / Make / n8n (workflow)	AI agent
Core job	Connect apps, run a fixed sequence	Reason and decide under ambiguity
Behaviour	Deterministic: same input, same output	Non-deterministic: judgment-based
Best input	Structured, predictable	Messy, ambiguous, exception-heavy
Cost	Free tier to modest monthly subscription	A custom build ($15K–$40K at KORIX)
Reliability	Very high for defined paths	High for judgment; needs governance
Use when	You can write the full rule down	You can't; the steps depend on a decision

They're not rivals: the best designs combine them

This isn't agents-versus-automation as a loyalty test. The strongest systems use both: a workflow tool handles the deterministic plumbing (triggers, moving data, notifications) and calls an agent only for the one step that needs a decision, then takes back control. You match each step to the right tool instead of forcing one philosophy onto the whole system.

The expensive mistake is building an agent to run an entire flow when 90% of it is fixed rules a $20-a-month workflow would handle flawlessly. A common shape looks like this: a Zapier or n8n flow catches every inbound email, files the routine ones by rule, and hands only the ambiguous, multi-issue ones to an agent that reads them and decides where they belong, then the workflow takes back over to log, notify, and close. The cheap, reliable rails run 90% of the volume, and the agent is reserved for the judgment that genuinely needs it. Good design is mostly knowing which 10% actually needs to decide.

When you should NOT build an agent, honestly

Say-what-others-won't time, even though we build agents for a living.

Don't build an agent if the process is fully rules-based — a workflow tool will be cheaper and more reliable.
Don't build one if predictability matters more than flexibility, because non-determinism is the wrong trait for, say, financial postings that must be identical every time.
Don't build one if an off-the-shelf workflow tool already solves it — buying a custom build to replace a working $20 zap is a waste we'll talk you out of.

We'd rather tell you to use Zapier and keep your budget than sell you an agent you don't need.

How we decide, in practice

On every engagement we map the flow first and ask, step by step: does this step follow a rule, or make a decision? The rule-steps go to automation; only the decision-steps get an agent. That discipline is why our builds ship.

Proteinverse, a 5-star Clutch engagement, combined deterministic automation for the order pipeline (which cut order-to-shipment time from 15–20 minutes to under 90 seconds) with intelligence only where judgment was needed. Numerology Matrix, a 5-star Clutch project, was a genuine AI application (live by day 18) because the core task actually required decisions, not just connections.

The honest question is never "agent or workflow?" in the abstract; it's "which does this step need?"

The bottom line: workflows connect; agents decide

If the task is a fixed set of rules (when X happens, do Y), a workflow tool like Zapier, Make or n8n is cheaper, faster, and the right answer. You only need an AI agent when the work requires judgment under ambiguity: reading messy input, weighing options, and deciding what to do next. Most "we need AI" requests are really "we need automation," and confusing the two is how budgets get wasted.

Written by Shishir Mishra, Founder & Systems Architect (AI) at KORIX — 19 years building AI and enterprise systems across finance, healthcare, logistics, and real estate.

Originally published at korixinc.com.

Shadow AI: your staff are already using AI. How do you make it safe?

Shishir Mishra — Thu, 27 Aug 2026 07:42:16 +0000

This article was originally published on the KORIX Learning Center.

They already are. Microsoft's 2025 UK research found that 71% of UK employees have used unapproved consumer AI tools at work, and 51% do so every week. The risk is not the AI itself; it is that it is ungoverned: no audit trail, no accountable owner, and client data leaving your control. Governance is what turns shadow AI into auditable AI you can stand behind.

You do not need a survey to know it is happening in your business, but the numbers make it concrete. Alongside that 71%, only about a third (32%) of employees say they are even concerned about the privacy of the company or customer data they put into these tools. And what goes in is not trivial: Cyberhaven's analysis of 1.6 million workers found that 11% of everything employees paste into ChatGPT is sensitive data. And the trend is accelerating: Zendesk's 2026 CX Trends Report found shadow AI use in some industries has grown by as much as 250% year over year.

The question is not whether shadow AI is happening in your firm. It is whether you can see it, and whether you could defend it if a regulator asked.

What "shadow AI" actually is

Shadow AI is your staff using consumer AI tools on real work, off the radar. Someone pastes a client email into ChatGPT to draft a reply. Someone runs a spreadsheet of customer data through a free summariser. Someone uses Copilot to write a policy document, or asks a chatbot to interpret a rule. None of it is logged, none of it is overseen, and often nobody senior knows it is happening. It is not malicious. It is people trying to get their work done faster with tools that are one browser tab away, and Microsoft's research shows the most common reason is simply that they already use these tools in their personal lives.

It is the AI-era version of shadow IT, the familiar problem of staff using unsanctioned software. The difference is that shadow AI does not just route data through an unapproved tool; it makes decisions and produces output that reach your customers, which raises the stakes. And it is not hypothetical: in 2023, Samsung engineers pasted proprietary source code and internal meeting notes into ChatGPT, and the company banned the tool within weeks.

The reason it matters is that these are not sandboxes. They are production: real client data, real decisions, and real output going to real customers, produced by a system nobody in your business can see into. The moment AI touches a customer outcome, it stops being a personal productivity trick and becomes part of how your firm operates, whether or not anyone decided it should.

Why it is a risk in a regulated business

For an insurance broker, a financial adviser, or anyone giving regulated advice, ungoverned AI creates four specific exposures. Take a broker whose account handler uses ChatGPT to speed up renewal summaries:

Data leakage. The client's details have been pasted into a consumer tool and left your control. You cannot say where that data went, who can see it, or whether it was used to train a model. Given that 11% of what employees paste into these tools is already sensitive, this is not a hypothetical.
No audit trail. Under the FCA's Consumer Duty you have to be able to evidence good customer outcomes. If AI shaped the summary, the recommendation, or the wording, and you cannot show what it did or why, you cannot demonstrate the outcome was good. Absence of evidence is the exposure.
Decisions no one can explain or reverse. A figure or a recommendation that came out of a black box, off the record, is one you cannot defend to a client, a complaint handler, or the regulator, and cannot cleanly undo.
Inconsistent output. Ten people using ten different tools their own way is not a process. It is ten different risk profiles, and no way to know which files are affected.

The common thread is the same one behind most failed AI projects: it is not the model, it is the absence of governance around it.

Shadow AI vs governed AI, at a glance

The same underlying tools sit behind both. The difference is entirely in the wrapper around them.

	Shadow AI	Governed AI
Where it runs	Consumer tools, personal accounts	Inside systems you control
Logging	None	Every action, full audit trail
Owner	Nobody	One accountable human, with a kill switch
Reversible	No	Yes
Client data	Leaves your control	Stays in your systems
Consumer Duty	Cannot evidence outcomes	Evidenced and defensible

The wrong fix: banning it

The instinct is to ban the tools. It does not work. A ban does not remove the pressure that made people reach for AI in the first place, the deadline and the workload are still there, so the usage just moves further underground, onto personal phones and personal accounts where you have even less visibility. You end up with exactly the same risk, minus the ability to see it, plus a team that has learned not to tell you what they are doing. PagerDuty's 2026 research found that a third of employees (33%) who use AI at work would hide it from their managers to avoid scrutiny; a ban only sharpens that instinct. The 71% figure is what usage looks like without a serious ban; drive it underground and you simply lose the 51% who currently do it in the open.

Enforcement makes it worse, not better. You cannot audit what you have pushed into the dark. The goal is not to forbid AI. It is to govern it: take the workflows your team already finds useful and bring them in-house on terms you can stand behind. That is the difference between renting a black box and owning an auditable system.

The governed pattern

Governing shadow AI means giving people the capability they were reaching for, inside a system you control:

An audit trail on every action, so you can show a regulator what happened and why.
One accountable human owner, with a clear kill switch, not a tool that belongs to nobody.
Reversibility, so any decision the AI influenced can be traced and undone.
Data that stays in systems you control, not a consumer tool's servers.
A human checkpoint wherever the consequence is high, and automation only where the work is routine.

This is what we build. On one document workflow we run, every action is logged for a 100% audit trail across 2,847 documents, and a human reviews only the cases the agent is unsure about. For a UK-regulated financial-planning workflow, every automated decision is fully audited, which is exactly what a Consumer-Duty environment requires. Across 50-plus governed builds the pattern holds: the useful work still happens, faster than before, and you can prove exactly how.

What to do this week

You do not have to solve all of it at once, and you should not try to. The first move is visibility, not a policy document. Find out, without blame, what AI your team is actually using and for what. People will tell you if the question is "how are you using this" rather than "who broke the rules." Then pick the one or two workflows that show up most, the ones with real client data or real client-facing output, and govern those first. Everything else can wait. Bringing two workflows in-house, logged and owned, removes more real risk than a ban ever will.

A five-question shadow-AI check

Ask these about your own business today:

Do you know what AI tools your team already uses?
Is any of that usage logged?
Is there one accountable owner for it?
Can you reverse a decision the AI influenced?
Does client data leave the building when your team uses these tools?

If the answers are no, you do not have governed AI. You have shadow AI. The good news is that the fix is not a ban or a big platform migration. It is bringing the handful of workflows that matter in-house, governed, in weeks.

The bottom line

Shadow AI is not a discipline problem. It is a governance gap.

Your team reached for AI because it helps. Banning it just hides it. The safe move is to bring the workflows that matter in-house, logged, owned, and reversible, with client data in systems you control. Governed, the same tools stop being a liability and become something you can evidence and stand behind.

Shishir Mishra is Founder & Systems Architect (AI) at KORIX, with 19 years building AI and enterprise systems across finance, healthcare, logistics, and real estate.

AI Agent vs Chatbot: Which One Does Your Business Need?

Shishir Mishra — Sun, 23 Aug 2026 07:42:33 +0000

Originally published at korixinc.com.

The difference between an AI agent and a chatbot is what each one is allowed to do. A chatbot answers questions: it recognises what you asked and returns a scripted or retrieved reply. An AI agent goes further, reasoning through a goal, deciding the next step, and taking multi-step actions inside your systems, usually with a human checkpoint and an audit trail. Put simply: chatbots chat, agents decide and do.

That one distinction changes your budget, your risk, and the outcome you can expect. This guide explains the difference in plain terms, gives you a side-by-side comparison, and helps you self-diagnose which one your business actually needs. We will also be honest about the cases where a chatbot is genuinely enough and an agent would be overkill.

What a chatbot actually is

A chatbot is a conversational interface over a fixed body of knowledge. The good ones today are powered by large language models and retrieval, so they sound natural and can pull answers from your documentation, help centre, or product catalogue. But the job is still fundamentally the same: someone asks, the bot responds.

A chatbot is excellent at a specific set of jobs:

Answering frequently asked questions
Deflecting repetitive support tickets
Pointing people to the right page, form, or human
Capturing a lead's details and qualifying intent
Explaining a policy, price, or process

What a chatbot does not do is act. It will tell a customer their refund policy. It will not process the refund, update the CRM, notify the finance team, and log the reason. The moment the task requires a decision and an action across more than one system, a pure chatbot hits its ceiling.

What an AI agent actually is

An AI agent is built around a goal, not a single question. Given an objective, it plans a sequence of steps, chooses tools or systems to use, executes those steps, checks its own work, and adapts if something changes. Andrew Ng, founder of DeepLearning.AI and former head of Google Brain, describes this through four agentic design patterns: reflection, tool use, planning, and multi-agent collaboration. In his framing, an agent that can iterate, revise its work, and call external tools produces markedly better results than a model that simply answers in one shot.

In practical business terms, an agent can:

Read an incoming document, extract the fields that matter, and file them in the right system
Triage a support request, resolve the routine part, and escalate the rest with context attached
Reconcile data between two systems that were never designed to talk to each other
Draft, check, and queue an action for a human to approve before it goes live

IBM defines an agentic workflow as one that approaches a problem in a multistep, iterative way, breaking a process into smaller parts so the system can plan, research, revise, and act. That is the core mechanical difference. A chatbot has one step. An agent has many, and it decides how they connect.

The word that matters most here is decides. An agent exercises judgment inside a boundary you set. That is powerful, and it is also exactly why governance is not optional.

AI agent vs chatbot: the side-by-side comparison

Dimension	Chatbot	AI Agent
Core job	Answer a question	Achieve a goal
Capabilities	Recognise intent, retrieve or script a reply	Reason, plan, choose tools, execute multi-step tasks
Decisions	None, or fixed decision-tree branches	Makes judgment calls within a defined boundary
Actions taken	Replies with text; may hand off	Reads, writes, and updates records across your systems
Systems touched	Usually one (the chat surface)	Multiple (CRM, email, docs, ERP, ticketing)
Memory / state	Session-bound, mostly stateless	Carries context across steps and, if designed to, across sessions
Governance need	Low (it only talks)	High (it acts, so it needs oversight and an audit trail)
When to use	FAQ deflection, lead capture, self-service	Repetitive multi-step work you want done, not just answered
Cost shape	Lower build, lower ongoing risk	Higher build, higher value, needs guardrails and monitoring
Failure mode	Wrong or unhelpful answer	Wrong action, unless a human checkpoint catches it

The last row is the one buyers underrate. A chatbot that gives a bad answer annoys a customer. An agent that takes a bad action can change your data. That is not a reason to avoid agents. It is the reason governed implementation matters, and it is the difference between a demo and something you can trust in production.

How to self-diagnose which one you need

You do not need a vendor to tell you this. Answer three questions honestly.

1. Does the task end in an answer, or in an action? If the outcome you want is that the customer knows the answer or the lead is captured, a chatbot is likely enough. If the outcome is that the invoice is reconciled, the ticket is resolved, or the record is updated, you are describing an agent.

2. Does it touch one system or several? Single system, single surface, mostly a chatbot job. If the work only counts as done when two or three systems agree, that coordination is agent territory.

3. Is the work repetitive, rule-heavy, and high-volume? A chatbot saves people from asking the same question. An agent saves people from doing the same multi-step task hundreds of times. If a capable new hire could learn the task from a one-page SOP and it recurs constantly, that is the strongest signal for an agent.

If you answered answer, one system, low volume, a chatbot is the right, cheaper call. If you answered action, several systems, high volume, you have an agent-shaped problem, and a chatbot will frustrate you by looking close but never closing the loop.

The honest part most vendors skip

Here is what a lot of AI agencies will not say out loud: most businesses that ask for an AI agent would be well served, at least first, by a good chatbot, and a meaningful share of agent projects should never have been agents at all.

The data backs the caution. Gartner predicts that over 40% of agentic AI projects will be cancelled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls. Anushree Verma, Senior Director Analyst at Gartner, put it bluntly: "Most agentic AI projects right now are early stage experiments or proof of concepts that are mostly driven by hype and are often misapplied."

So we will say it plainly. An AI agent is not the right fit if all you need is FAQ deflection, lead capture, or self-service answers; in that case a chatbot is cheaper, faster to ship, and genuinely fine. Do not pay for an agent to do a chatbot's job. As KORIX founder Shishir Mishra puts it, the skill is not buying the most advanced thing, it is matching the tool to the outcome, and reaching for an agent only when the work genuinely involves decisions and actions across systems.

Where agents are the right call, the value is real and the direction is clear. Gartner projects that 33% of enterprise software applications will include agentic AI by 2028, up from less than 1% in 2024, and that at least 15% of day-to-day work decisions will be made autonomously through agentic AI by 2028. Deloitte's 2025 Predictions report expects 25% of companies using generative AI to launch agentic AI pilots in 2025, rising to 50% by 2027. The shift is happening. The question is whether you adopt it where it earns its keep, or where it just sounds impressive.

What "governed" adds, and why it is the real decision

Once a system can act, the interesting question stops being chatbot or agent and becomes how do we deploy an agent we can actually trust. This is where most of the risk in that Gartner cancellation number lives, and it is the part KORIX is built around.

A governed agent has four things a demo usually lacks:

Human oversight at the points that matter. The agent drafts and prepares; a person approves the consequential action. You decide where the checkpoint sits.
An audit trail. Every decision and action is logged, so you can answer why did it do that after the fact. Regulated and finance-adjacent teams cannot operate without this.
It runs inside your existing software. Rather than forcing you onto a new platform, a governed build works within the stack you already own and pay for. We call this approach Bring Your Own Software. We did not invent the idea; we are simply one of its more disciplined practitioners.
You own the build. No lock-in, no dependency on a vendor's proprietary black box. If we walked away tomorrow, your agent keeps running.

To make this concrete: one KORIX document-processing agent runs at roughly 2,800 documents processed at 98.3% accuracy, inside the client's own stack, with a human checkpoint on the exceptions. That is not a chatbot answering questions about documents. It is an agent doing the work, with a trail that shows exactly what it did. On cost, a focused chatbot build often lands in the low thousands of dollars; a governed agent is a larger fixed-scope engagement, and our AI Pilot starts from around $10,000 and puts a governed agent live in about 21 days so you can judge it on your own data before committing further.

Bottom line

A chatbot answers. An AI agent decides and acts. That is the whole difference, and it maps cleanly onto what you are trying to achieve. If your goal ends in an answer, on one system, at modest volume, buy the chatbot and spend the savings elsewhere. If your goal ends in an action, across several systems, at high volume, you have an agent-shaped problem, and a chatbot will only ever get you halfway.

The mistake to avoid is treating AI agent as a status symbol. Gartner expects more than 40% of agentic projects to be cancelled by 2027, largely because they were reaching for an agent where a simpler tool, or a clearer problem, would have served better. The businesses that win with agents are the ones that pick a real, repetitive, multi-step workflow, deploy a governed agent inside their existing software with a human in the loop, and prove it on their own data before scaling.

If that is the workflow you have in mind, the fastest way to know for sure is to run it, not debate it. A governed AI Pilot puts one live in about 21 days, on your systems, with the audit trail from day one. Bring us the single task your team keeps doing by hand, and we will show you whether it is an agent's job or a chatbot's, honestly, before you spend on the wrong one.

Shishir Mishra is Founder & Systems Architect (AI) at KORIX, with 19 years building AI and enterprise systems across finance, healthcare, logistics, and real estate.

Your staff are already using AI. How do you make it safe?

Shishir Mishra — Fri, 21 Aug 2026 07:52:24 +0000

They already are. Microsoft's 2025 UK research found that 71% of UK employees have used unapproved consumer AI tools at work, and 51% do so every week. The risk is not the AI itself; it is that it is ungoverned: no audit trail, no accountable owner, and client data leaving your control. Governance is what turns shadow AI into auditable AI you can stand behind.

What "shadow AI" actually is

Why it is a risk in a regulated business

Data leakage. The client's details have been pasted into a consumer tool and left your control. You cannot say where that data went, who can see it, or whether it was used to train a model. Given that 11% of what employees paste into these tools is already sensitive, this is not a hypothetical.
No audit trail. Under the FCA's Consumer Duty you have to be able to evidence good customer outcomes. If AI shaped the summary, the recommendation, or the wording, and you cannot show what it did or why, you cannot demonstrate the outcome was good. Absence of evidence is the exposure.
Decisions no one can explain or reverse. A figure or a recommendation that came out of a black box, off the record, is one you cannot defend to a client, a complaint handler, or the regulator, and cannot cleanly undo.
Inconsistent output. Ten people using ten different tools their own way is not a process. It is ten different risk profiles, and no way to know which files are affected.

The common thread is the same one behind most failed AI projects: it is not the model, it is the absence of governance around it.

Shadow AI vs governed AI, at a glance

The same underlying tools sit behind both. The difference is entirely in the wrapper around them.

	Shadow AI	Governed AI
Where it runs	Consumer tools, personal accounts	Inside systems you control
Logging	None	Every action, full audit trail
Owner	Nobody	One accountable human, with a kill switch
Reversible	No	Yes
Client data	Leaves your control	Stays in your systems
Consumer Duty	Cannot evidence outcomes	Evidenced and defensible

The wrong fix: banning it

The governed pattern

Governing shadow AI means giving people the capability they were reaching for, inside a system you control:

An audit trail on every action, so you can show a regulator what happened and why.
One accountable human owner, with a clear kill switch, not a tool that belongs to nobody.
Reversibility, so any decision the AI influenced can be traced and undone.
Data that stays in systems you control, not a consumer tool's servers.
A human checkpoint wherever the consequence is high, and automation only where the work is routine.

What to do this week

A five-question shadow-AI check

Ask these about your own business today:

Do you know what AI tools your team already uses?
Is any of that usage logged?
Is there one accountable owner for it?
Can you reverse a decision the AI influenced?
Does client data leave the building when your team uses these tools?

The bottom line

Shadow AI is not a discipline problem. It is a governance gap.

Originally published at korixinc.com.