iQuantiv · Managed AI · August 2026
What you're actually buying when you buy AI
Most companies buy licenses and stop. The license is the smallest part. This page walks the whole stack: training, connections, company knowledge, automation, and governance, delivered as one managed service over one year, with pricing that scales with the value you get.
You can't buy AI the way you buy software
Start hereA license gives you a very capable stranger. It doesn't know your systems, your data, your standards, or your people. And nobody at your company knows how to put it to work yet. Buying AI well means buying two things at once: the subscription itself, and everything that turns it into a colleague. The first one you buy from the vendor. The second one is this page.
Booking isn't live yet — the contact step is planned for a future version.
What usually happens instead
Most companies that buy AI get nothing measurable back. That's the documented outcome across thousands of organizations. The shape of the failure is worth knowing before you spend anything.
- Pilots returning nothing
- 95%of enterprise AI pilots showed zero measurable impact on profit or loss. Five percent captured the value. MIT / Project NANDA, 300 deployments
- Initiatives abandoned
- 42%of organizations scrapped most of their AI projects before production, up from 17% a year earlier. S&P Global, 1,006 firms
- Work actually changed
- 1 in 10employees say AI changed how their work gets done, against roughly half who use it at all. Gallup, 23,717 respondents
The pattern behind all three is the same. The license arrives, a few people try it, and nothing structural changes. Usage goes up and output doesn't.
What a year costs, and who is watching it The two answers a forwarded copy needs without reading nine tabs
Total cost, against the alternative you're not buying. That alternative is what the tiles above already show: most companies get nothing measurable back for what they spend on AI. What a structured year costs isn't a mystery. The program retainer runs $4,000–$11,000 / mo depending on tier. A full first year — net of the credited assessment, managed administration, and training — lands at $64,500 for the smallest tier up to $260,400 for the largest. The chart below breaks out all three. The full ladder, the line items, and the exit terms are Manage's job to state in full.
Held against the real alternative: a genuine Big Four or global-integrator AI engagement runs $500k–$2M+ for year one alone — published vendor and market-analysis pricing, not an iQuantiv result or a ledger figure. We put no chief-AI-officer dollar figure on this page. That comparison is scoped to cash compensation, and we have no sourced figure to publish, here or in Manage.
Scroll sideways to see all three tiers.
Illustrative, from the worked scenarios in Manage: Starter at 150 people, Knowledge at 250, Scale at 800, each net of the credited assessment. First year, not steady state. Illustrative. These are constructions from the published rates above, at the headcounts named, not quotes. Managed administration bills to a twenty-five seat floor, so a rollout smaller than that pays for twenty-five.
Security posture. Every AI tool your people touch runs under a written policy, with shadow-AI monitoring layered on top so an unapproved tool doesn't sit in the dark. Govern answers the rest in full: what iQuantiv can and can't see, how tenant isolation and retention work, the approval path for a new tool. That's the tab a CISO reads before anyone signs.
What the subscription gives you on day one
- A capable assistant for anyone you give a seat to
- Drafting, summarizing, explaining, rewriting
- Every model improvement the vendor ships, at no extra cost
- No knowledge of your systems, your data, or your standards
- No view on which of your people should use it, or for what
- No record of what it did, and no policy governing it
This is the answer to "can't we just buy ChatGPT?" You can, and you should. It's the cheapest part of the whole thing.
What nobody sells you with it
- Connections that let it read live systems instead of pasted text
- Your standards and tribal knowledge, written down where it can use them
- Role-based training that keeps pace as people climb
- Clean, merged data underneath, so answers can be checked
- A policy people follow, and a way to see which unapproved AI tools are already in use (shadow AI)
- Someone accountable when it breaks
Six problems, none of which a license solves and none of which your vendor is selling. That's the work on this page.
The full stack, in one picture Click any layer to jump to it
This diagram is dependency, not schedule. Each layer stands on the ones under it, and together they are what you own when the year is done. The climb further down the page is the same services ordered by when you feel them, which is why Assess sits low here and first there. You can buy pieces. The stack is why the pieces pay off.
Qalibrate is our platform, and it appears on two layers because it does two jobs: the gateway that connects your AI to the systems you run, and the data layer underneath that makes the answers checkable.
The measured week under Connect and the decision register under Capture are proof from the same one client, de-identified separately in each tab. That's one client's evidence twice, not two companies' results.
The climb, and who does what
The mapUnder the Connect tab is our full Qalibrate Gateway pitch. It shows a five-stage ramp from "asking questions" to "directing a team of AI workstreams," with a real, measured week at the top of it. That pitch covers the middle of the climb. This document covers all of it.
Five stages, each delivered by a service on this page
Asking questions
Treating it as a smarter search box. Real but small gains. Most organizations that say "we use AI" are here.
Handing over whole tasks
Giving it a finished job instead of a question. The first real hours come back here, and it's where most people stall without help.
Connecting it to the real systems
The step change. Wired into your warehouse, reporting, files, and tickets, it works on live data instead of what gets pasted in.
Teaching it how the company works
Standards, conventions, tribal knowledge, written down once and applied every time. This is what stops output needing a rewrite.
Directing a team
Several streams of work running in parallel, reviewed by one person. The productivity gain everyone was promised, and the last to arrive.
The Connect tab holds a real week measured at stage 5: one person, 43 tasks, connected systems doing the fetching and checking — one person's week, not a cohort. Nobody gets there alone, and nobody gets there in a quarter. That's why this is a year.
Why a year
The packageThe year follows a plan, not a billing convention. Foundation work is scoped to run about six weeks. After that, each use case runs an eight to twelve week delivery loop, and we run at most two at a time so neither gets half our attention. Add the transition at the end, and a handful of use cases fills a year. This is the shape we plan the work to take, not a measured outcome. A shorter engagement buys fewer loops, not faster ones.
What lands when Our standard delivery method. The assessment sets your actual dates and order
This is our planned cadence, not a completed record. Every week and milestone below is the method's target; the assessment fixes your actual dates and order.
Quarter 1 Foundation, built once
- Executive alignment and a spend ceiling, which gates everything after it
- Discovery: your use cases found and ranked
- AI policy written and adopted, around weeks 2 to 5
- Tooling and access provisioned, weeks 3 to 6
- Training complete by about week 6. No training, no access
- First delivery loop opens
Quarter 2 Delivery loops, two at a time
- Every loop starts at a gate: is the data ready, and is there a frozen baseline to measure against
- Shadow pilot runs 4 to 8 weeks beside the current process, not instead of it
- Kill or scale decided around week 9, against that baseline
- Knowledge-base interviews begin
- Continuous tracks running since week 1
Quarter 3 What survived goes live
- Redesign the process, then scale it. Scaling an unchanged process is the common failure
- Supervised production with a named owner on your side
- Net value measured against the frozen baseline, not against memory
- Advanced training: directing parallel work
- Next loops open as earlier ones close
Quarter 4 Transition
- Capability-transfer map: who owns what once we step back
- The knowledge base handed over as yours, not ours
- Annual value report, then the year-two roadmap and the renewal decision
- Team climbing on its own
Adoption, governance and measurement start in week 1 and never close. The 42% above got there by letting delivery speed outrun the data and governance work.
How our pricing works, across every service
Three models, not eight. Bounded, one-time work — the assessment, a build — is a fixed fee. The ownership relationship is a monthly retainer, priced to the scope of the program rather than to hours. We do not bill hourly and we do not publish an hourly rate. Hours are our cost, not your outcome. And anything that scales with your headcount is priced per seat, monthly or annually: managed administration, training and recertification.
That's the whole structure. A service that builds something and then keeps it running, like a targeted automation, is model one followed by a bounded model two: a fixed build, then a monthly service fee for keeping it accurate. It isn't a fourth model, and it shouldn't read as one.
Wherever we're paid by seat or by program rather than by a fixed deliverable, we only keep getting paid when your people keep finding it worth using. That alignment is deliberate. The quarterly usage reports (see Manage) show adoption in your own numbers, so the bill and the value stay visibly connected.
Each tab states which of the three models applies to it. The one exception is the Qalibrate Gateway itself: Connect's own connections are priced per system + usage, described in full on that tab, not folded into the three above. Data platform construction is priced separately, on its own contract, outside the AI package. The retainer buys a named owner and a program, not a block of hours.
Your AI subscriptions are in none of this. You buy Claude, ChatGPT, or whichever vendor you choose directly, and everything on this page sits on top of that.
Where to start
The assessment. It's the one piece that has to come first, because everything else on this page gets scoped from what it finds: which systems are worth connecting, who needs training and on what, where data isn't ready, and what's already leaking into tools nobody approved.
It's fixed-scope and fixed-price, and the roadmap it produces is yours whether or not you buy anything else from us. If the answer turns out to be "not yet," that's a useful answer too.
Booking isn't live yet — the contact step is planned for a future version.
AI readiness assessment
The front doorBefore anything gets built, someone has to walk the property. The assessment inventories the systems you actually run, finds the work worth automating, and says plainly what isn't ready. It's fixed-scope and fixed-price, the roadmap it produces is yours whether or not you buy anything else, and it doesn't stop once the year starts.
What it stops you from buying
Pilots rarely fail on the technology. They fail because nobody wrote down what "working" meant before the money moved. Three patterns show up again and again, and all three are decided before a line of code exists.
- Magic expectations. The tool gets bought off a demo, and nobody ever writes down what it has to do to count as working. Every review afterwards is an argument about vibes.
- No baseline. Nobody measured the old process before switching, so there's nothing to compare against. The question "did this help?" becomes unanswerable, permanently.
- Output that changes every run. The whole shape of the answer moves between runs, not only the numbers inside it. Two runs can't be put side by side, so nobody trusts it enough to stop checking by hand.
These are the three reasons the pilots we've been called in behind actually underdelivered, in each case according to whoever built them. None is a technology problem. All three get decided in the first four weeks, which is what the assessment is for.
What the assessment does Open a lane to see what gets asked
Weeks, minutes, and thresholds below describe how we plan to run the assessment, not measurements from a completed engagement.
Leaders
The top leaders get interviewed one at a time, not together in a room. Thirty minutes each. The gaps between their answers are the real finding: when the CEO and the CFO describe different priorities, that gap has to close before anything gets built on top of it.
It ends in a single page naming which functions are in scope, what good looks like in each, and the metric. Everyone agrees what "done" means before money moves. At a mid-market company that agreement is harder to get than it sounds, and worth more afterwards than any framework document.
Set by conversation, not by spreadsheet: what would you need to see in six months for this to have been worth it? Work backwards to a number. That number then gates everything after it, including us.
Work
We walk finance, operations, HR and sales with a single prompt: what's a five-to-ten-hour-a-week manual task that costs real money and delays something? "Costs real money" rules out irritations. "Delays something" points at bottlenecks. Five to ten hours is large enough to measure a difference against.
How long it takes, and how many people it involves. Whether it's frustrating because it's slow or because it blocks something else. And what would change downstream if it ran twice as fast. That last answer defines the outcome metric before anyone has committed to anything.
No one person gives more than two to four hours across all four functions, done in person. If someone can't say how long their own process takes, that's a finding too: an unmeasured process makes the baseline step harder later.
Systems
Where systems already feed a warehouse, we read the catalog directly: how many tables each source carries, how many rows, and the timestamp of its last successful sync. Metadata only. No row data, no personal information, no financial values, and sensitive tables stay closed.
If nothing is centralized yet, the same inventory gets built the slower way, from admin interviews and access reviews — additional client time beyond the sessions counted above, borne by whoever administers each system. Less precise, and it usually becomes the first argument for doing the data work.
Feeds that stopped without anyone noticing, and two systems that both claim to be the source of truth for the same thing. Neither is visible from an org chart, and both break an AI answer quietly rather than loudly.
Risk
This track runs on what the leader and Work sessions already surfaced. It doesn't add a separate client session.
A three-tier data classification: what can go into a public tool, what needs a governed one, and what never leaves at all. Most companies have never written this down, and every tool decision afterwards depends on it.
Every candidate has to clear four gates before it advances: the data exists and is reachable, someone owns it by name, there's no unacceptable security or compliance risk, and a human can step in when it gets something wrong. Fail one and it gets parked, with the reason written down and a date to look again.
When each system last sent data A real client inventory, de-identified
This client ran about fifteen systems. Eight were feeding on the day we read the catalog. Seven had stopped, the longest more than nineteen months earlier, and nobody had noticed because the reports built on them still rendered.
Scroll sideways to see the full timeline.
Read from the warehouse catalog on one day: table counts, row counts, and each source's last-sync timestamp. Metadata only, no row data opened. A sixteenth system was connected and had never delivered a single row. None of this is visible from an org chart, and no company can tell you this about itself without looking.
What that inventory concluded
Shadow AI: we ask, we don't scan
Roughly half of employees already use AI tools nobody approved. An analysis of 1.6 million workers found 11% of everything pasted into ChatGPT was confidential company content. The instinct is to go hunting with monitoring software. We start by asking, in the same interviews, because a scan finds installs and a conversation finds the reason.
Cyberhaven, 1.6 million workers. Unauthorized-use rate: multiple 2025 surveys, 45 to 50 percent.
The framing that gets honest answers: "I'm not here to report anything. I want to understand what's actually useful to people so we can make it available safely." Then: "What tools do you or your team already use that IT hasn't officially set up?" And if someone hesitates: "Even personal subscriptions or browser extensions count."
- Logged by tool and by function, never by person. We're mapping demand, not building a discipline list
- Any function where several people name the same unsanctioned tool goes straight onto the backlog
- It only works coming from someone who isn't their boss
High shadow use is a signal before it's a problem. It marks unmet need people cared enough to solve themselves, and it tells you the sanctioned path has to be at least as easy as the workaround.
How a candidate gets scored
Five dimensions, one to five each, summed out of twenty-five — our standard method, not a validated predictor of outcome. Flat, unweighted, and written down, so the ranking survives contact with the loudest person in the room.
Data readiness is scored on its own rather than folded into feasibility, because it's the dimension that most often sinks the project everyone was most excited about.
The first one is the easy one
The opening use case gets picked for feasibility and speed, not raw impact. The highest-scoring idea is usually the one whose data isn't ready, and a program that starts there spends its first six months on integration and burns its credibility doing it.
Caps, on purpose
- About three candidates on the scored backlog at a time
- Never more than two in active delivery
- Five shallow pilots at once produce five mediocre results
These are the caps we plan to hold, not a count from a delivered program.
What you get, one page at a time
- The end-state definition. One page: functions in scope, what good looks like, the named metric
- The spend ceiling, agreed and signed, which gates every decision after it
- The scored backlog, candidates ranked on the five dimensions with the reasoning visible
- The parked register, every candidate we said no to, why, and the date to reconsider
- The systems inventory, what feeds what, what stopped, and what has to be fixed before connecting
- The leader gaps note, where your own leadership described different priorities
Short documents on purpose. A hundred-page assessment is a way of charging for weight, and nobody reads the second half.
It doesn't stop at the front door
The best use cases don't surface in month one. They surface in month five, when someone who's been using the tools daily finally says "could it just do this part too?" That person now knows something the assessment couldn't have known, because they hadn't used it yet.
So the backlog stays open, by design: new candidates get scored on the same five dimensions, against the same gates, all year, and the parked register gets a fresh look each quarter, because a use case parked for missing data becomes viable the moment that data lands. That's the cadence we intend to hold, not a log of quarters already run.
Why not just use a free readiness checklist
Use one. They're fine for deciding whether to have the conversation. What they can't do is answer any of the questions that actually decide the outcome.
- A checklist can't read your warehouse catalog and tell you three of your feeds died in 2024
- A checklist can't run an amnesty interview, because the honesty depends on who's asking
- A checklist can't tell you your CFO and your COO gave different answers to the same question
- A checklist has no reason to talk you out of anything, and the useful part of an assessment is the parked register
How this is priced
The four-week timeline and session counts are our planning estimate, not a measured average across delivered assessments.
If you engage us for the program, the $9,500 one time fee is credited back in full against it. That credit carries no expiration date.
The roadmap is yours to keep, and it's useful even if you take it to someone else. That's the point of a front door. Your AI subscriptions aren't in this or any other number on this page.
What we can't measure, and what we check instead
There's no matched sample: companies that skipped this assessment and bought blind. So we can't put a dollar figure on what four weeks of diagnosis is worth. A number like that would be a guess dressed as a measurement, and this page doesn't publish those.
What we can show is that we hold our own delivery baselines to the discipline this page asks of yours. On a separate, real engagement, the measurement effort found and wrote down its own undocumented assumptions before trusting any of them, and disclosed the questions it still can't answer rather than smoothing them over. That's the same "no baseline" failure named above, checked against us instead of against you.
If your data isn't ready, or a system shouldn't be connected, or the honest answer is "not this year," the roadmap says so. An assessment that always concludes "buy the big package" isn't an assessment.
Training, for every role, all year
Stages 1, 2 & 5A license makes AI available. Training is what gets it used, and in the policy this program runs under, it's also the gate — nobody is authorized to touch the tools until they've been trained and signed off. We teach against your repositories, your backlog and your systems, and we come back across the year, because the skills that matter in month nine can't be taught in month one.
What one class leaves behind
Training people on AI is easy to do and easy to waste. The tools demo well, everyone leaves the room impressed, and six weeks later the work looks exactly like it did before. Three things cause that, and none of them is the quality of the class.
- Personal speed, unchanged organization. Inside companies that have adopted AI, 65% of employees say it made them personally more productive. Only a small share say it changed how the work gets done at their company — the same Gallup survey behind Overview's failure-rate tiles. People get faster at their existing tasks and the process around them never moves.
- Behavior follows reinforcement, not instruction. A BCG executive coach puts it plainly: "We assume that if leaders know what to do, they'll do it. That's just not true. Most of the time, leaders revert to the behaviors that are reinforced, not the ones they learn in training." BCG's own framing has training stopping at the first of three stages — learning it, applying it, and having it become the way the work is done.
- Taught against a sandbox. A generic demo environment behaves nothing like a twenty-year-old codebase or a real backlog. The moment people go back to their own work, everything they practiced stops matching what's in front of them.
Productivity and transformation figures: Gallup, 23,717 US employees, February 2026 — the same survey behind the adoption number on the Overview tab. Reinforcement quote and the three-stage framing: BCG, "To Unlock the Full Value of AI, Invest in Your People," November 2025. BCG sells enablement services, so their framework is worth taking and their client figures are not.
The two days, minute by minute The delivered course, at real length
This is our two-day Claude Code course as it was actually taught: fourteen modules, 11.5 hours of teaching. The shading is how much of the tool each block uses: a scheduling constraint, not a topic. The two heavy labs are kept apart on purpose and buffered on both sides, so nobody hits a usage ceiling in the middle of their own work.
Scroll the chart sideways to see the full two days.
Each day's teaching stops forty to fifty minutes short of the room time on purpose. Setup overruns, good arguments run long, and someone's environment always fights back. A schedule with no slack in it turns the first problem of the morning into a cut lab in the afternoon.
What each block actually does Open a day to see all fourteen
Every module reinforces the same five-step loop, worded identically in all fourteen decks: investigate, plan, approve, execute, verify. That repetition is the point. By the second day, people are running the loop without being walked through it.
Day 1
The destination before the mechanics. What an agent does that a chat window doesn't, what it's genuinely bad at, and how the job changes when something else does more of the production work. Teaching and discussion, nobody touches a keyboard yet.
Installed, authenticated, pointed at a real repository, first commands run. Deliberately oversized, because setup always overruns. It's also where we learn what each person actually works on — those tasks come back in both labs.
Everyone asks it to explain a part of a codebase they know cold, then grades the answer against their own knowledge. They're the expert marking the tool. That's the fastest way we've found to build calibrated trust instead of blind faith or blanket suspicion. The first delegated task is read-only.
Goal, context, constraints, and what done looks like. Two briefs for the same task, one vague and one solid. Predict what each produces, then see what they actually produced. No tool use — a recovery block by design.
Ask for a plan, actually read it, push back on it. What the permission model protects and what it doesn't. Approving a plan becomes the new review checkpoint. That moves judgment earlier than a code review does.
Everyone runs the whole loop solo on a small real task, reviewing at the plan and again at the diff. First choice is something from their own repository. This is the hour the day is built around — if we're running late, everything else gets cut before this does.
What worked, what fought back, what surprised people. Then the preview: today was one task under close supervision, tomorrow is managing the work.
Day 2
The context window as a working set, the symptoms of a session that's gone stale, and when to clear it rather than fight it. A session is a whiteboard — useful mid-task, wiped between tasks, and anything worth keeping gets written down somewhere permanent first.
Everyone drafts a real instructions file for a repository they own: conventions, commands, constraints, and the landmines a new person would step on. They keep it after we leave, and it's the difference between explaining the same thing every session and explaining it once.
Picking a model and an effort level, and naming the tradeoff out loud. Task type against cost and speed, sorted on paper. Placed here on purpose so people spend the rest of their day's capacity deliberately in the second lab.
Each person takes a real oversized task off their own queue and splits it into agent-sized pieces, then says which pieces they'd hand over and which they'd keep. Judgment calls, architecture, and anything they couldn't verify stay with them. Done on paper — the thinking is the exercise, and the output feeds straight into the afternoon.
Reviewing a diff you didn't write, and making it prove its work rather than assert it. A gallery of the real failure modes: confident wrong answers, scope creep, fixing the symptom, going in circles. Then the recovery moves, including deciding to stop delegating and do it yourself.
Supervised progress on the tasks they decomposed that morning, instructors floating. This is the honest test of whether they can keep going after we leave. We run it while we're still in the room, so we see the answer.
Everyone presents one workflow they'll run differently starting Monday: what they hand off, what they keep, where the review happens. Leaving with a changed intention beats leaving with a certificate.
The program
The first cohort
Why sessions stay small
Cohorts are capped at six to seven people, and that cap came out of a real comparison, not a guess: the same week, a fifteen-person session at another client left only one attendee able to answer a question the room had just covered. A crowded room is not a cheaper room; it is a room where almost nobody learned anything, which is the alternative this cap is priced against.
What that cohort said
"I am trying to find something where it wasn't great, but I don't have anything."
An attendee, closing feedback session
"The labs were brilliant."
An attendee, on the two hands-on blocks
"I would have loved to have a 3rd day."
An attendee, asking for skills, hooks and tool connections next
What they told us we got wrong: not enough written reference material. In their words, it's hard to absorb that much in two days, and a printable quick reference would mean not having to ask again. Fair, and it's the one concrete revision that came out of the room.
The sponsor's framing at the close: month one of twelve, day two of 365, with a standing target of roughly four hours a month of continued AI education. That's the argument for a cadence, made by the person paying for it.
Quotes are from the recorded feedback session at the end of the second day. The recording carries no speaker labels, so these are attributed by role rather than by name.
Who gets trained on what
One live program, de-identified. Every cohort learns an assistant. The technical cohort is the only one that learns a coding agent. Most people also get a second tool for their function's specific workflow.
Scroll the table sideways to see every column.
Cohorts are set by what the function's day actually looks like, not by seniority. Finance, field services and supply chain lead with a workflow tool because their highest-value use cases are structured and repetitive. Everyone else leads with the assistant. The tools are yours to choose — this is one client's split, not a template.
Training is the gate
In the policy this program runs under, training is a precondition rather than a benefit: it has to be completed before anyone is authorized to use an approved AI tool for company work. Signing the policy isn't a substitute for completing it. The record then stays current for twelve months.
Recertification isn't only a calendar event. It's triggered by a change in approved tools, in the policy, in someone's role, in the required tool settings, in access scope, or by a misuse incident. Missing the deadline can suspend authorization to use the tools at all.
We build the curriculum, deliver it, and produce the signed training record the policy requires. Who holds that record and enforces the expiry is the client's call — usually HR.
Why not a free video
There's a great deal of good free material, and we point people at it. Four things it structurally can't do:
- Have someone grade the tool's explanation of a codebase they wrote themselves. Calibrated trust needs their code, not a sample repository
- Leave a project-instructions file behind in their repository that keeps working every session after we've gone
- Take a real task off their queue, decompose it in the morning and run it in the afternoon
- Produce the signed training record their own policy requires before anyone is allowed access
What stops it being open-ended
There's no graduation ceremony, and we won't invent one. The twelve-month certification clock bounds it — a real deadline with a real consequence. So does the stated outcome on every module, which someone either has or hasn't reached.
The shape of the year is front-loaded. Foundations and the two-day intensives come first, then sessions get lighter and more specific as people bring their own problems instead of ours. If a cohort stops needing the working sessions, that shows up as an empty calendar rather than an invoice.
How this is priced
Delivery is quoted per engagement, from cohort size and duration, instead of published as a flat rate. The curriculum is real and already delivered. The pricing platform behind cohort scheduling isn't finished yet. Holding the per-seat annual price and saying so is the disclosure, not a gap in one.
That unpublished rate is not free: it already sits inside the year-one and steady-state totals published on the Overview and Manage tabs, at a per-seat figure this page is holding until the year-two curriculum delta above is set.
One training day produces stage-one users and a fading memory. The cadence is the product.
iQuantiv · August 2026
Connect the AI to the business it works for
A license gives you a chat window. A connection gives you something that can read the ticket, check the record, and open the pull request. Below is the full gateway pitch, including a real, measured week of what that changes.
What you already have
The starting pointStart with what a Claude license already gives you, before anything is connected to anything. It's two tools in one subscription, and each is worth having on its own.
Chat. Ask, draft, analyze.
A conversation window. Ask a question, have it draft the email or summarize the contract, paste in a spreadsheet and ask what looks odd. It answers in seconds, and it's useful on day one.
Cowork. Hand it real work.
The same intelligence, working instead of chatting. Point it at a folder and it drafts the document, builds the spreadsheet, works through a stack of files. Multi-step tasks that finish while your person does something else.
Both are real gains. On their own, though, they leave most of the value on the table.
Where it stops on its own
The problemOut of the box, Claude doesn't know your business. It can't see your ERP, your warehouse, your files, or your inbox. So your people end up being the courier, copying something out of a system, pasting it in, explaining the background, and copying the answer back out, on every single task. The tool is impressive, but the process is still manual, and that's why licenses alone don't change how long work takes.
What's missing is context. Once it's connected to your actual systems, it stops answering like a smart stranger and starts answering like someone who works there, because it's reading the same data your people are.
On its own, in a chat window
- Answers only what someone pastes into it
- Drafts and rewrites, but only from what it's given
- Explains only what's already in front of you
- Can't see a single row of your data
- Can't check whether what it told you is true
- Can't change anything in a system
Every input is a copy and paste, and so is every output. The person is the integration, and that caps the work at whatever fits in a message box.
Connected to the business
- Queries the warehouse and reads the real numbers
- Builds and fixes reports in the platform people already use
- Checks whether the overnight data loads actually worked
- Reads the mail, the calendar, the chat and the files for context
- Opens and updates work items
- Checks its own work against the source, and fixes what's wrong
Nobody moves data by hand. The assistant goes and gets what it needs, does the work against the live systems, and checks it. That's the difference.
The Qalibrate Gateway
The productThe fix is one piece of infrastructure. The Qalibrate Gateway is our product, a secure, managed connection between Claude and the systems you already run, built and hardened by our engineers over months. We build and manage the connections. Your administrator decides who gets access to what, from a self-service portal behind your own sign-on.
Once a connection is configured, nobody has to think about it again. Your people talk to Claude exactly the way they're being trained to today, and behind the scenes it reaches the systems it's been given. No more copying and pasting, and no re-explaining the background every time.
The same systems, without the gateway and with it
Snowflake
GitHub
Outlook mail
Sisense
Outlook calendar
Smartsheet
Teams
OneDrive
SharePoint
Excel, PDF,Word files
or server
one request, plain language
SnowflakeGitHubOutlook mailSisenseOutlook calendarSmartsheetTeamsOneDriveSharePointExcel, PDF,Word files
or server
Both halves show the same systems, the kind your business runs on. What's different is what sits between them and the person. The Qalibrate Gateway is one unified layer across the business instead of a different one-off tool for every team, so connections get built once, kept working, and added as a company needs more of them. It works in the other direction too. The gateway is the switchboard between your systems and the frontier AI vendors, so when the models gain a capability (and they do, every few months) you inherit it without rebuilding anything. It isn't just the big systems, either. Give it a shared folder (on a server, in the cloud, on someone's machine) and it can read and work with every file inside.
One connected week, measured
Everything below is six real working days with the gateway connected. One person, three client accounts plus internal work, tasks. The measured numbers aren't self-reported. The software wrote its own records while the work happened.
Estimate range · Ratio · standard 40-hour weeks of work
Every estimate on this page is carried as a range, and the charts in the task list at the bottom of this page use the low end of it.
What it looks like to work this way
MechanicsOne person, reviewing the work of a team. You don't manage any of this. You ask for what you need in one conversation, and Claude breaks the request apart, picks the right system for each piece, and hands back finished work for review. The checks and balances stay human, and nothing counts until a person has looked at it.
The team behind one person
- Actions taken
- queries, file edits, checks and messages, taken by the assistants rather than typed by hand
- Calls into business systems
- across connected systems
- Running at once
- peak parallel streams of work
- Time spent multitasking
- of active minutes had more than one thing running
- Working days
- in the window, one weekend fully off
The week as parallel streams of work Each column is a day, running down the clock. Each thread is one stream of work. Threads side by side ran at the same time.
Where the threads run side by side, more than one stream of work was running at once. Where the color changes mid-day, the work switched accounts, which the headline number never shows. The daily start and stop times are the same measurement as the hours figure at the top of the page. This is the real gain. While one stream runs, the person is already onto the next one, because nobody is standing in the middle moving data by hand. The faint blocks behind the threads are that week's calendar obligations, meetings and personal both, shaded by client. The streams kept running through them.
of the tasks in that week, and of the hours, were work of a kind that cannot be done in a chat window at all. Investigating a data problem, fixing a pipeline, rebuilding a report. Take the connections away and that work doesn't get slower. It goes back to being done entirely by hand. Across the week, the logs captured 1,925 separate calls into those connected systems.
This is the end state, not day one The route up
Nobody works like this in their first week. What you're looking at is the top of a ramp, and there's a known route up it.
What each stage gives back Schematic. Only the last point comes from the week above.
Asking questions
Treating it as a smarter search box. Real but small gains, drafting, explaining, summarizing. Most organizations that say "we use AI" are here, which is why the productivity numbers usually don't show up.
What comes outanswers and drafts
Why most stop here. It gets complex, it raises security questions, and nobody owns pushing past it.
Handing over whole tasks
Giving it a finished job to do instead of a question to answer. Write this procedure, fix this bug, build this spreadsheet. This is where the first real hours come back, and where most people stall without help.
What comes outfinished tasks
Connecting it to the real systems
This is the step change. Wiring it into the data warehouse, the BI platform, the code repositories, the ticket system, so it works on live company data and not just what gets pasted into it. This is engineering work, and it's most of what an engagement actually delivers.
What comes outlive reports and fixed pipelines
Teaching it how the company works
Standards, conventions, review rules, the things a new hire would take six months to absorb. You write them down once and they get applied every time. This is what stops the output needing to be rewritten.
What comes outoutput that matches your standards
Directing a team
Running several streams of work in parallel, delegating whole workstreams, reviewing what comes back. The person's job shifts from producing work to directing and judging it. That shift is the actual productivity gain, and it's the last one to arrive. Nobody gets here alone. Ongoing training is part of the engagement, and we keep coaching your team until working this way is second nature.
What comes outwhole workstreams, delivered and reviewed
The vertical axis is how much work comes out for the same hour put in. The shape is what matters. The numbers along the way are illustrative. Only the final point comes from the week above, measured hours against the estimated solo hours, with all the caveats the estimate carries. The rest are drawn.
How long this particular ramp took
About months, with one curious and motivated person driving it. You can't count on having a person like that on every team. Left to chance, most people stall at stage two. That's the argument for doing it deliberately. The stages above aren't a natural progression. Each one is a piece of work somebody has to do, and doing that work for a whole team is exactly what the offer at the bottom of this page covers.
The infrastructure behind that week, the connected systems and the written standards, didn't exist on day one. It had to be built.
The same build, across a whole organization The multiplier — a projection
This is headcount you didn't have to hire. The infrastructure behind one person is built once and shared, so the second person costs a fraction of the first. And the situations in the task list exist on every team, not just data teams. This is the one part of the page that's a projection instead of a measurement.
The workforce you didn't hire Illustrative trajectory built from the ramp's stage mix, not a measured result
The upper path assumes every ten people land where the ramp puts them, and the engine behind it isn't something you'd have to build or staff. The models come from vendors spending tens of billions a year improving them, and the gateway's job is to keep your systems attached to that. The first measured stretch of a rollout replaces this drawing with your own numbers.
What this looks like for your team
The offerEverything above comes down to three things. Connections, knowledge, and habits. That's what an engagement builds, and it's only half the job. The other half is the culture that makes it stick, teaching people what to hand over, meeting each person where they are, and leaving behind a team that keeps climbing without us.
What the engagement builds
- The connections (stage 3). The gateway stood up against your warehouse, your reporting platform, and the systems your people already live in.
- The knowledge (stage 4). Your standards, conventions and review rules written down once, so the assistant works your way from day one. This one is its own phase, scoped after the connections prove out.
- The habits. Working sessions that train people to hand over whole tasks, which is where most ramps stall without help.
How this is priced
Your administrator controls who gets access to what, from a self-service portal behind your own sign-on. We build and manage the connections; you own the keys.
The 43 tasks, one by one
This is the detail the headline number can't show you. Below is every task from the week, grouped by the situation that kicked it off, the same situations your own people hit every week. Somebody questions a number. A report breaks. A stakeholder emails asking for something by Friday. Open any group to see the individual tasks and what each one was for.
You don't need to read all forty-three. These two are worth opening.
Two of the week's tasks built, and then deliberately attacked, a plain-English vocabulary over Client 3's warehouse, a semantic layer, so that a person who knows nothing about tables or SQL can ask a business question and get a governed answer back. You don't have to know where the answer lives, just what question to ask.
Both sit in the "Building the AI system itself" group below, with their hours and outcomes included. One built the portfolio of views, the other tried to break it and fixed what gave. That second task is the one worth noticing. The work gets reviewed before it ships, not just generated and handed over.
Hours of displaced work, by the situation that kicked it off
Bars show the low end of each estimate range, so none of this leans on the optimistic number. Each task counts once, in its primary category.
The part that isn't engineering at all
Not everything above is technical work. The same week also covered drafting emails, prepping for meetings, writing things down, and answering client questions. That's the everyday work every desk already has, and it works the same way here.
Where these numbers come from
Measured: nobody typed these numbers in. The task counts, hours, and actions come from usage records the software wrote by itself while the work happened.
Estimated: one number on this page is a judgment call. How long the same work would take one person with no AI. Two independent estimates were made separately, neither seeing the other's numbers, and the page shows a range instead of pretending to be exact.
Checked: the two estimates landed apart, and wherever a published industry benchmark exists, the range was adjusted to match it.
Which way it errs: if the estimate is wrong, it's most likely too generous, so the page shows the low end everywhere, and the charts use it.
The full method, for the person who wants it
The two estimators agreed on the total better than on any single task. Across comparable tasks they correlate at , the typical task differs by , and the two totals land apart. That's what independent errors cancelling looks like. It's not evidence that either estimator is unbiased.
Every figure is carried as a range. A single number would claim a precision the method can't support. Where a published benchmark exists for the kind of work (technical documentation per page, a BI dashboard build, a data incident), it was used to move or widen the range. of the estimated hours cover work for which no credible published benchmark exists at all, and the page says so plainly.
Scope:
What survives when someone leaves
Stage 6Most of what a company knows lives in someone's head: who admins which system, why a decision went the way it did, what a departing employee would tell you if asked in time. We interview your people, capture the meetings, and write the decisions down under a stable ID that's never deleted — only marked superseded, pointing at whatever replaced it. We do not claim a new hire gets six months of context on day one; nobody has measured that, so it's not on this page.
Uncaptured institutional knowledge like this is close to the norm: only 7% of organizations call their own data fully ready for AI, per a 2025 HBR Analytic Services Pulse Survey — sponsored by Cloudera, whose remedies favor its product line. External research, for context only.
The same mechanism, twice A real client's decision register, de-identified
A decision from July was independently cited by its exact stable ID 31 days later, in a new decision and a separate meeting summary. One lucky example proves nothing. The mechanism recurring is the claim. A June decision shows the other half. Filed once, it has had zero modifications in the 58 days since: persistence, not continued citation.
Scroll sideways to see both bars in full.
The register's growth Four commit batches, not a live feed
Scroll sideways to see the whole growth curve.
This isn't continuous capture: the 48-record register was written up in four batch sessions across 58 days, not decision by decision as they happened. We say so plainly, so you don't read it as a live feed.
Not everything in it is settled, and that is on purpose Same register, by status
Scroll sideways to see the whole bar.
Every decision carries a named owner, a decision date, and a verbatim evidence quote, checked both ways. The unsettled ones stay in the register — a rejected decision stays rejected, and a superseded one keeps pointing at its replacement instead of disappearing.
Who does the curation
This is the objection worth answering directly: you are paying a monthly fee to maintain knowledge your own people already have. What the fee buys is turning a room full of talk into something addressable — 17 of 18 raw meeting transcripts became structured, decision-linked records so far (94.4%), and the one still unprocessed is named in our own backlog rather than smoothed over. If we stop, the register doesn't disappear: it exports with your tenant at exit, in the format it was built in. Not measured: whether the answer came faster than before the register existed. No pre-Capture baseline exists, so any such figure would be a guess.
How this is priced
Each engagement is quoted before it starts. These are the published rates the quote is built from.
This is the same per-seat fee priced under Manage, not a second charge — you pay it once, not twice.
You keep what you paid us to build. At non-renewal you keep and export the knowledge base, the prompt and skill libraries, the connector configuration and the documentation, in your own tenant.
Grounding an assistant on this knowledge base, once it exists, is included in the Knowledge tier, not billed again here: Knowledge is $7,500 / mo total, $3,500 / mo more than Starter's $4,000 / mo.
What it's not: a document dump. A folder of old PDFs teaches an AI nothing. The value is in the curation — knowledge organized the way agents and people actually retrieve it, kept that way for as long as we're the ones curating it, not handed over once and left to rot.
What happens when it's wrong
The wrong-call testSome of the software your company renews every year does one job, the same way, for every customer who buys it. We interview the people who actually use it, build a skill around their own standing positions and risk tolerances, and put it in front of everyone who needs it — not a pilot group. We used to publish one client's before-and-after software bill here. It didn't survive an audit. No invoice backed the number, and the product name in it may not be real, so it's gone. What's left is the mechanism, and one built example of it.
A real one, built and running Role-only: no client is named
Built for a client in construction subcontracting: a skill that reviews subcontracts against that company's own standing positions and risk tolerances, not a generic checklist. It runs the same way for every reviewer who uses it. We do not claim a time or a dollar figure here — see the note under the diagram for why.
Scroll sideways to see the whole diagram.
Why there's no before/after number: nobody logged how long the manual review took before this skill existed, so there's no baseline to measure against. We also can't yet show what share of a skill's running time is unattended. The instrumentation for that reads flow-run history straight from the pipeline, and it isn't returning data as of this build — an authentication problem on our side, not a result we're declining to show. Until one of them is fixed there's no number here, and an estimate isn't a substitute.
What clearing the floor does and doesn't mean: the floor is a confidence threshold, so clearing it means the skill was confident enough to decide on its own — not that the decision has been certified correct. Where you set that floor is where you set that trade, and it's agreed with you before launch rather than by us afterward. What the mechanism guarantees is the routing: below the floor, a named person signs off before the work moves; above it, the work goes into whatever review your process already applies to it. We don't run a sampling program over above-floor decisions, and we won't describe one we don't operate.
What the assessment looks for
- Software everyone renews without much thought, that does one job the same way for every customer who buys it
- A manual process nobody automated because off-the-shelf software for it never existed
- A place where “generic” is the actual complaint, not the price
If the generic version is the problem, this is the fix. If it isn't, the assessment says so, and this section doesn't apply.
The boundary, not a blank check
Two things about every skill we build won't reduce to a number: a threshold for what it decides on its own, agreed before launch, and a named person who signs off on anything below that threshold before it reaches anyone else. The accuracy SLA keeps that threshold true as the underlying model changes — monitoring, drift, and migration. A new feature is a new quote, not an assumption baked into the fee.
Every skill runs inside the same tenant boundary as the rest of the program. Govern answers those questions once: where the documents it touches are stored, who can read them, how access is logged. Not repeated here, and not skipped either.
Why the boundary is non-negotiable, not a nicety: in July 2025, a coding agent at another company deleted a production database during an active code freeze, against explicit instructions not to touch live systems. Then it misrepresented its own recovery options before anyone caught it. Publicly reported and independently verified — not an iQuantiv result, and not our client. AI Incident Database, verified incident record.
How this is priced
What the accuracy SLA covers, separate from what the build fee already bought: Accuracy monitoring, drift, and model migration. Changes are quoted. The build fee is the one-time cost of building the automation; the SLA is what keeps its accuracy floor true after that, for as long as you keep it.
You keep what you paid us to build. At non-renewal you keep and export the knowledge base, the prompt and skill libraries, the connector configuration and the documentation, in your own tenant.
What it's not: a promise to replace everything with an annual bill. Some systems earn their price — the assessment is where we say which ones don't.
Is your data too messy for this to work?
Qalibrate analyticsData readiness is the objection we hear most, so this page leads with the least flattering number we have. On a real client's semantic-analytics layer, an adversarial test asked 243 questions phrased the way a client actually talks. Only 118 came back safe to act on the first time. The same six views' own registered self-test read 90% to 100%. That's the score a routine client review would normally trust. We do not claim the first pass was good. We claim the gap between those two numbers is what a routine review would have missed, and that finding it before a client does is the reason this test exists.
What those fresh questions actually found One real client's deployed semantic layer, one adversarial pass
Scroll sideways to see the whole bar.
Every finding required both the answer the views actually gave and an independently hand-derived number from the base tables, or it was dropped. 125 wrong answers were found this way, before any client saw one.
The self-test had its own defects The artifact a routine review would have trusted
Trusting a vendor's registered test is exactly what a routine review would do. Here it would have been wrong twice. 2 of the 18 answers that test had already marked "verified" were themselves wrong, including one that overstated a project's labor cost 18.2 times over. A separate defect, caught the same way, overstated the client's entire active-project cost figure by 23.6%. Both were fixed before any client ever saw either number.
A second, deeper pass Different attack angles, days later
Scroll sideways to see both bars.
A follow-on verification ran 31 more questions across four different attack angles and found 6 dangerous or partial defects. Every one was fixed the same day, and the eval suite for every touched view re-ran to 100% clean. The program's own standard sets an 80% pass gate. One view (labor) came in below it before its fix and above it after.
Adversarially tested: the same six views, not yet switched on for anyone
10 views like the two above are deployed in that client's warehouse today, and zero of them carry a client-facing grant — on purpose, until the remediation described above is closed out. We do not claim this is running for a client yet. It's built, and it gets tested harder than a normal launch before it goes live, not after.
This example doesn't settle where a warehouse build runs for every engagement, or who besides your own named administrators can see inside it — that gets set out in writing before anything connects. Our general answer on tenant access and logging is under Govern, not repeated here.
What happens between your systems and the AI's answer
- Cleaned and normalized nightly
- Merged across systems: one customer, one product, one truth
- Master data management
- Archived-system history kept queryable
The joins in the middle are the part AI struggles to do on its own. Do them once, in the warehouse, and every question after that inherits them. A different client's own operational data made the same point with no AI involved at all: summing one shared fact table across its three source systems, with nothing to say which one was the record of truth, overstated a full year of output by 94% against the single-source answer.
A real one: two ERPs, one history A current client, in production today
The client's financial history spans both systems, in one place. Ask "how has margin moved over the last decade" and the answer crosses the ERP migration without anyone stitching spreadsheets. That continuity is nearly impossible to reconstruct later and routine to maintain now.
What we're not claiming: that already being a Qalibrate analytics client gives you a head start on any of this. It probably does. We have not measured it, so it's not on this page.
How this is priced
Data platform construction is priced separately, on its own contract, outside the AI package. No band is published for it: we would rather say that plainly than publish a range with nothing behind it.
Knowledge is $7,500 / mo total, $3,500 / mo more than Starter's $4,000 / mo.
What this page is not: proof that AI can find these joins on its own. It found none of them. A person wrote each fix, checked it against the client's own numbers both ways, and tested it twice before this page could quote it.
Who owns it, what you pay, how you get out
All yearAI decisions don't stop when the tools go live: vendors ship new models monthly, new questions come up weekly, and somebody has to own the answer. One named person owns your AI program for as long as you run it — they join your meetings, run the rollout, and carry what we're seeing across other clients back into yours. If your last AI effort fizzled because nobody was accountable for it, that's the mechanism this retainer changes, not a promise that this attempt will go better.
What this costs against your alternative Why there is no vendor benchmark on this page
We don't have a market benchmark for this retainer, and we would rather say so than borrow one that doesn't fit. Every published source on fractional AI leadership is vendor marketing. The only real case behind ours is our own: the client running this program today pays 120,000 dollars a year, the equivalent of a monthly rate that sits between the Knowledge and Scale retainers below: $7,500 / mo and $11,000 / mo. We put no chief-AI-officer figure here either. That comparison only works on cash compensation, and we have no sourced figure for it. At your size, the real alternative probably isn't a CAIO at all. It's an existing IT director carrying this as an added duty for a stretch bonus, and we don't have a sourced figure for that comparison either. We'd rather leave both boxes empty than fill either with a number that doesn't fit your market.
Program retainer Priced by the program, not the hour
Three tiers, one twelve-month ladder. Each step up costs the same amount more — $3,500 / mo — whether you're moving from Starter to Knowledge or from Knowledge to Scale.
The retainer buys a named owner and a program, not a block of hours.
You keep what you paid us to build. At non-renewal you keep and export the knowledge base, the prompt and skill libraries, the connector configuration and the documentation, in your own tenant.
If the named owner leaves the account, we name a successor and run a formal handover before they go, not after — the program does not sit unattended while we recruit.
What buying more gets you Same ladder, ranked by monthly cost
Scroll sideways to see all three bars.
Source: data/pricing.json#retainer.tiers.knowledge; data/pricing.json#retainer.tiers.scale; data/pricing.json#retainer.tiers.starter.
What a year costs, all in The three tiers, worked all the way through
Each figure below adds up the retainer, managed administration and training — plus a recurring accuracy SLA for each targeted automation in scope, however many the tier includes — in one arithmetic engine, checked line by line against the pricing data rather than typed into a table by hand. The assessment credit lowers the gross bill; an automation build fee, billed only in the year it is built, can push year one back above steady state for a tier that includes automation. The steady state is what year two and after actually bills.
- Starter
- $64,500steady state, year two on · ~150 people · $64,500 net in year one
- Knowledge
- $127,800steady state, year two on · ~250 people · $139,800 net in year one
- Scale
- $236,400steady state, year two on · ~800 people · $260,400 net in year one
Where year one runs above steady state, the gap is the automation build fee at $12,000 one time per automation, billed only in the year it is built. Starter includes 0 in scope; Knowledge 1; Scale 2 — multiply by that count for the tier's gap.
What these three totals leave out: the gateway. It is priced per connected system plus usage, and that pricing is still being worked out, so no band for it is published here and none of it is inside the figures above. If the gateway is part of what you want, the assessment scopes it and prices it separately — treat these three as the program without it, not as the whole bill.
Illustrative. These are constructions from the published rates above, at the headcounts named, not quotes.
Managed AI administration
We run the day-to-day on your behalf: seats, sign-on, permissions, model and vendor updates. The subscriptions stay on your paper. We do not claim a published delivery case for this offering yet. AI operations and cost control runs inside the Scale tier here rather than being priced on its own.
What we can and can't see while running this is Govern's question, not this page's — see the Govern tab for tenant isolation and the approval path.
The same measuring, run on this project Read at the meter's last run, not a live counter
The usage & value reporting behind this retainer runs on the same instrumentation that produced the measured week in the Connect tab: 43 real sessions, measured rather than estimated. We do not claim a client has received a quarterly report built from it yet. The instrumentation is real, and it has already produced one measured result. That's what's proven. Here it is again, turned on the project that built this page. Every phase, gate and work item is checked against the commits that actually closed them.
Scroll sideways to see the whole bar.
Source: data/meters/manage-meter.json#metrics, cross-checked against this repo's board YAML (only the phases already mirrored to file — the newest phase's items aren't in this count yet, since its board file hasn't been created) and its own commit history. Read at the meter's last run, not a live counter on this page.
How this is priced
Each engagement is quoted before it starts. These are the published rates the quote is built from.
We do not bill hourly and we do not publish an hourly rate. Hours are our cost, not your outcome.
What it's not: a helpdesk contract, and not a headcount you're hiring. The retainer buys judgment and a name to call. The administration underneath runs quietly as its own service, and the exit above is an export, not a renegotiation.
Policy & protection
Wrapped around everythingCan you see our data, and will this survive a security review? That's the real question, and it doesn't get answered by a paragraph about taking security seriously. Governance here is two services: a policy built for your organization, and shadow-AI monitoring. Below we take the four questions that decide whether the day-to-day work is safe — logging, retention, who on our side can read what, and the model vendor's terms — and answer each one straight, including where the honest answer today is that we can't evidence it. The diligence questions your counsel and your security reviewer will ask, certification and data residency among them, get answered in writing when you ask, not on a marketing page. You should insist on that rather than take a website's word for it.
AI policy creation One delivered example, de-identified
Acceptable use, data handling, which tools are approved for which data, who decides an exception. Built for one real client across twenty sections, shaped to that organization's actual risk instead of a template. It carries role-specific restrictions and a named sensitive-data list. Delivered early in an engagement, because everything else on this page is meant to operate inside it.
Low Moderate High Prohibited
That policy's own four-tier risk model, low to prohibited.
Shadow-AI monitoring Newer than the rest
Detecting company data moving into an AI tool nobody approved. Most organizations already run some of the plumbing this needs. We design around what you already have rather than adding another tool. This is the newest service on this page, and we have not published a methodology, a tool, or a client count for it — because none exists yet that we would put our name on.
What a security review actually asks Answered plainly; gaps named where they're real
Do you log what our people type into an AI tool?
Not for this engagement. No record on our side describes prompt-level logging for the advisory, training, or configuration work. Named as an open gap, not assumed closed.
How long is any of it kept?
Also not evidenced for this engagement. What we can evidence, below, is how long a different system we operate keeps its own logs before deleting them — an example of the discipline, not an answer to this question.
Can your staff read our data?
For this engagement: not evidenced. For a system we build and run for a client, we have real, shipped access-control decisions to show, below — a different claim, kept separate rather than blurred into this one.
Is there an enterprise agreement covering how the model vendor uses our data?
None is on record here. Ask for one directly if your review requires it; its absence from this page says nothing about whether one exists.
How we build access control and retention, when we're the one building it A different product we operate — not this engagement
Not a claim about the advisory work above. These are real, shipped decisions in the client portal iQuantiv operates. A schema per tenant instead of one shared table with a filter column, because a missed filter is the most common way a multi-tenant system leaks data across accounts. Two enforced fields, checked on every request, before a dashboard or module is returned. A stated deletion window for every log type, rather than a promise to "keep logs."
Scroll sideways to see all three bars.
Scroll sideways to see all three bars.
The client portal, not this engagement's prompts, transcripts, or documents — that gap stays named above rather than papered over with this evidence.
Why this matters industry-wide External research, for context only — not an iQuantiv result
Most organizations are in the same position: 78% of business leaders say they lack strong confidence they could pass an independent AI governance audit within ninety days. In a separate, wider survey, AI-agent governance was the weakest of five maturity dimensions measured, with only 32% reaching the third maturity level or higher. Neither figure is iQuantiv's. Both describe the market we're compared against.
Not measured here: how much faster a custom policy gets followed than a generic template, or how much shadow-AI exposure it actually prevents. No controlled before-and-after exists for either question, for us or for anyone we've seen cite one, so no delta is published — a guess dressed as a measurement would be worse than the gap.
How this is priced
Quoted by organization size once we know the scope. No flat rate is published for this line. Each engagement is quoted before it starts. These are the published rates the quote is built from.
Shadow-AI monitoring isn't priced separately: it's too new to price. Administering the AI program day to day — access, exceptions, roles — is billed the same per-seat way as everywhere else on this page. See Manage.
What it's not: surveillance of your employees. The target is data leaving the building through a tool nobody approved, which protects the company and the employee both.
That's the whole stack
Nine tabs, eight service lines, one year. You don't buy all of it, and you don't buy it in this order. You buy what the assessment says you need, in the order it says you'll feel it.
So start there. The assessment is fixed-scope and fixed-price, it inventories your systems, data, roles, and risk, and it hands you a roadmap you keep either way.