Authoring plane
K Forge
Agents are assembled from typed steps, tools and connectors. Every step declares what it reads and what it may touch.
The agentic operating systemfor regulated industries
Kinett gives AI agents a governed place to work. Guardrails decide what each agent can see and do, extra protection sits around every action, and the people accountable for the outcome stay in control.
Your best people lose their days to drafting and checking — careful work that rarely needs their expertise. Agents can do that work, but ungoverned agents trade one problem for another: audit gaps and compliance risk. Kinett is the operating system your agents work on: they act only within the limits you set, with governance built in from the first task. Every decision they reach arrives with a record of exactly how they got there, so your experts review the result instead of rebuilding it.
The runtime is horizontal. The expertise ships as domain packs. That is why a new industry takes weeks, not years.
Live in daysnot quarters
Audit-readytamper-proof by default
Three ways to runmanaged, your cloud, or your own
Domain packsfinance, healthcare, and yours next
The problem
Building an agent is easy. Proving it stayed inside the lines is not.
Every regulated AI deployment stalls on the same four questions. With an agentic toolkit, each answer depends on someone remembering to build it in. With Kinett, the answers come built into the platform.
What was it allowed to do?
With an agentic toolkitWhatever the code happened to permit on the day it shipped.
With KinettDeclared limits. Every step declares what it reads and may touch, and the agent cannot widen those limits.
What did it do?
With an agentic toolkitPieced together from logs, which takes real digging, and even then the logs may not hold what you need.
With KinettA tamper-proof record. Every run is recorded, and exportable for your examiner in one click.
Why did it do that?
With an agentic toolkitA model's answer, with no source behind it.
With KinettCited, versioned knowledge. Pinned to the run, with every figure traced to a tool result.
Who is accountable?
With an agentic toolkitNo one is clearly named, so no one will sign off, and the agent never gets past the pilot.
With KinettA named approver. Every consequential action waits for a named person to approve it, so someone always answers for the outcome.
How it works
Three planes. One governed runtime.
Every agent in every vertical is authored, proved and run the same way, inside the same context. That shared path is what makes the governance credible.
Control plane
K Context
The versioned harness an agent runs inside: knowledge it cites, records read fresh, limits it cannot widen.
Runtime plane
K Run
Executes in production, durably and at scale, after the agent is proved in the Lab on your real cases.
Why it pays off
The fourth agent brings no fourth set of controls.
Permissions, the audit trail, approval routing and your system connectors belong to the platform. A new agent is only its own vertical work, and it arrives already governed.
WealthPortfolio reviewsends a client note
- own permissions
- own audit log
- own approvals
- own connectors
ComplianceSuitability checkupdates your CRM
- own permissions
- own audit log
- own approvals
- own connectors
Health planPrior authorizationpauses for a person
- own permissions
- own audit log
- own approvals
- own connectors
NextThe one you ask forsame rules on day one
- own permissions
- own audit log
- own approvals
- own connectors
The same platform, under every agent
- One set of connectors
- One audit log
- One set of permissions
- One approval queue
- One place to look
Built to guarantee
Built from regulated discipline. Ready for agentic work.
Four properties the runtime enforces on every agent that runs on it, the same way for the first as for the hundredth. They are architecture, not policy, which is why a new agent arrives already governed instead of waiting on a review of its own.
Authority only narrows
Organization, agent and step limits sit inside each other. Nothing widens them.
Decision and evidence, together
The action, who allowed it and who approved it are recorded at the same moment, in one step.
Your data stays in your perimeter
Every component runs in your cloud; models are called through your endpoints.
No model authors a figure
Every consequential number is read from source and recomputed.
Who it's for
Pick the industry. The platform stays the same.
Each vertical ships as a pack of steps, checks and connectors, fitted to your process.
Banks · RIAs · broker-dealers · insurers · lenders
Kinett Finance
Wealth, compliance, underwriting and analytics, with the audit trail regulators expect.
- Wealth Management
- RegTech & AML
- Underwriting
- Data Transformers
Kinett Healthcare
Network, utilization, claims and clinical data. The decision stays with the person accountable.
- Provider Network
- Prior Auth
- Claims Integrity
- Quality & Risk
Your vertical
If the work runs on documents, rules and decisions someone signs off on, it fits.
Start a conversationHow we start
One workflow, proved on your data before it touches anything.
1
Pick one workflow
A clear trigger, a clear output, and volume that hurts.
2
Get the rules out
From the screens, the SOPs and the people who know them.
3
Prove it before it acts
On your real cases, every side-effect stubbed.
4
Turn it on, governed
Inside its limits, with approvals routed to named people.
Under the hoodK Forge · K Context · K Run
Every agent arrives already governed.
An operating system decides what may run, grounds what it works from, executes it and records what happened. This is the detail behind each of those: the planes, the discipline, the architecture, and how it compares.
The three planes
Three planes. One runtime underneath all of it.
Authoring planeK ForgeAuthor the agent
Control planeK ContextGovern what it may do
Runtime planeK RunRun it, and prove it
A platform, not an agentic toolkit
Everything passes through one governed path.
The usual way
an agentic toolkitControls are rewritten inside every agent, so every agent is a fresh review for risk and compliance.
The Kinett way
a platformOne governed path. The model and your systems are only reachable through the platform, never directly.
Inside each plane
One codebase. Three responsibilities.
No agent can opt out of any of them.
K Forge what it does
Declared steps, not prompts
A sequence with a contract per step. The same case takes the same shape every time.
Contracts and checks
Each step declares inputs, outputs and the checks that must pass. Dependencies are enforced at runtime, not trusted.
Legacy-first connectivity
File drops, exports, direct reads, screen-level integration. The estate does not have to move first.
Reviewable without code
The declaration the runtime executes is the one your process owner reads. There is no second diagram.
K Context what it does
What it knows
A versioned, diffable knowledge base. Every rule traced to where it was captured and who confirmed it. The agent cites it rather than recalling it.
What it may do
Limits only ever narrow: organization, then agent, then step. A request to widen is refused, never quietly trimmed.
The shield
Default deny, evaluated per action: allow, deny, or hold for a named person.
What it leaves behind
The action, the reason and the approval commit as one transaction, isolated per organization.
K Run what it does
Durable runs
Every step is checkpointed. A crash, a deploy or a rate limit resumes where it stopped.
The Lab
Shadow-mode on live data with side-effects stubbed, compared against what your team did.
Replay
Re-run captured production runs against a new version.
Per-step model routing
Long-context here, small-and-fast there, no model at all where it's arithmetic. Swapping provider is configuration.
The discipline
Harness engineering. Reliable by design.
Governance decides what an agent may do. The harness decides how well it does it. A step that is safe but wrong still fails the pilot, so the harness is versioned and pinned to every run.
Guides · before the model acts
Declared readsOnly what the step asked for is in context.
Tools run firstTyped tools return facts before the model reasons.
Cited knowledgeVersioned, and pinned to the run.
Sensors · after the model acts
Schema checkedThe output must match its contract.
Figures recomputedEvery number traced and checked against source.
Policy recheckedAgain at the shield, before anything acts.
Deterministic outside, agentic inside. The steps never change shape, so there is something stable to approve. Inside a step, the model reasons freely.
Deployment
Your perimeter, your choice.
Three ways to run Kinett. In every one, your data never has to leave.
We run it
Your workspace on Google Cloud, isolated per organization, with no infrastructure for you to manage. Whitelabel to your brand is included.
You host it
Import Kinett as libraries into your own GCP, AWS, Azure or data center. Records stay inside your compliance boundary, and we maintain the runtime.
You own it
Buy the source outright. The platform, the knowledge base behind your agents and the runbook for changing them are all yours.
Architecture · the boundary
All of it runs in your cloud account.
A request is admitted, deliberated, enforced and recorded on the way down. Your data does not leave your account, and models are called through your own cloud's endpoints.
SandboxedStep execution
- no network
- no filesystem
- no secrets
Event journalFacts, appendedIt holds no truth of its own. The journal in your database is the record. No message broker required.
How we compare
A layer, not a competitor to everything.
Frameworks give you wiring, inference platforms give you speed, policy engines answer one question about one request. None of them holds the two layers a regulator asks about.
Kinett holdsThe two layers a regulator asks about, plus the packs on top
Your vertical workflowFinanceHealthcareYours nextshipped and tuned with you
The agent's contextK Contextheld by Kinett
Agent runtimeK Runheld by Kinett
bring your own below
ModelsClaudeswap freely
Inference & siliconCerebrasswap freely
InterchangeableUse the models and providers you prefer
| Shipped out of the box | Managed runtimesAgentCore · Vertex | Policy enginesOPA · Cedar · Cerbos | KinettForge · Context · Run |
|---|---|---|---|
| A definition a non-engineer can review | |||
| Knowledge versioned and pinned to the run | |||
| Pre-action authorization on every tool call | |||
| Human approval as a policy outcome | |||
| Decision and evidence in one transaction | |||
| Replay captured runs against a new version | |||
| Run it in your own cloud, or own the source |
shippedvaries by productnot shipped by this layer
See it run, on your own data.
Bring a real workflow and your architecture questions. We'll walk through it on your data, in your cloud.
Kinett FinanceBanks · RIAs · broker-dealers · insurers · lenders
Your team should be making decisions. Not drafting them.
Purpose-built agents for wealth, compliance, underwriting and analytics. They handle document review, drift checks, SAR drafts, credit memos and regulatory filings, with the audit trail that comes with all of it.
Governed by defaultevery agent inherits the controlsAudit-readytamper-proof by defaultSaaS or on-premyour data, your perimeter
What we handle
Work that arrives at your desk, ready to review.
Agents do the heavy lifting in the background, so your team makes the calls only people should make.
A portfolio drifts 8% off its IPS in equities. The agent flags it, drafts a rebalance memo with the suitability check attached, and routes it to the advisor in minutes.
A FinCEN advisory drops overnight. The agent extracts the obligations, maps them against your AML procedures and drafts a redline with tracked changes for review.
A commercial loan application arrives. The agent pulls bureau data, runs covenant checks, drafts a decision with adverse-action language pre-vetted, and flags only the two items that need judgment.
A vendor sends 200 statements. The agent parses each one, normalizes the schema, resolves entities and feeds structured records downstream overnight.
Workspaces
Built for the way your team is organized.
Each workspace ships with the agents and models for that function, ready on day one.
RIAs · wealth · fund managersWealth ManagementPer-client briefs, drift catches and anniversary reviews, drafted, sourced and ready to send.
banks · broker-dealers · insurersRegulations & ComplianceAML and SAR drafts, reg-change tracking and sanctions screening, with one-click regulator export.
home loans · consumer · commercialUnderwritingDecision drafts with rationale, covenant checks and adverse-action language pre-vetted.
domain models · extractionData TransformersStructured, decision-ready signal from PDFs, statements, filings and contracts.
A problem we've built for
Commercial real-estate underwriting intake.
A lender receives a rent roll, an operating statement and a loan application in whatever format the borrower sent. Someone spends hours normalizing, computing coverage and flagging what doesn't reconcile.
Credit memo agentExample run
Arrives
Rent rollxlsx, any layout
Operating statementPDF
Loan applicationdocx
The agent
Extract and normalize fields
Compute ratios in code
Flag what doesn't reconcile
Draft the credit memo
Leaves
Credit memoevery figure cell-referenced
Heldfor the underwriter to sign
- Reads the documents as they arrive: xlsx, docx, PDF, inconsistent layouts
- Extracts and normalizes the fields, then computes the ratios in code, not in a model
- Flags what does not reconcile against the source, with the cell it came from
- Assembles the credit memo and holds it for the underwriter to sign
Bring us the memo that takes all week.
Show us the work your analysts redo every week. We'll show you an agent drafting it, with the evidence attached.
Kinett HealthcareHealth plans · TPAs · network management · provider groups
Your team should be making decisions. Not assembling them.
Every figure traceable, every decision left with a human. Agents across network, utilization, claims and clinical data. They handle credentialing, rate construction, criteria evaluation and edit rationale, and leave the decision with the person accountable for it.
Every rate explainedthe binding constraint, namedDecisions stay humanagents propose, people signPHI stays putSaaS or on-prem, your perimeter
What we handle
The case assembled. The call left to the clinician.
Agents assemble files, schedules, packets and rationale in the background, so your team makes the calls only people are allowed to make.
The agent prices the code set three ways (benchmark, market parity, budget envelope), takes the lowest on every code, names the test that bound it, and routes the schedule to the lowest approval tier it clears.
Each criterion is marked met, not met or insufficient, with a reference to the page it came from. The medical director opens an assembled case.
Each flagged edit comes back with the documentation and policy it was applied under, so the analyst confirms a rationale instead of reconstructing one.
Two hundred scanned attachments are parsed, normalized, matched to practitioners on the roster and fed downstream overnight.
Workspaces
Six workspaces across the plan.
Each ships with the agents and models for that function, and they share one governed runtime underneath.
network management · contractingProvider NetworkOnboarding, credentialing, network fit and the fee schedule, with the constraint that set every rate named on the record.
UM nurses · medical directorsReferrals & Prior AuthClinical evidence evaluated against your criteria, cited line by line, routed to the clinician who decides.
claims ops · payment integrity · appealsClaims & Payment IntegrityEdits with a stated rationale, and appeals rebuilt from the audit trail instead of from memory.
enrollment ops · member supportEnrollment & Member ServicesEligibility reconciled across sources, correspondence drafted against the plan the member is actually on.
quality · risk adjustment · codingQuality & Risk AdjustmentCare and documentation gaps, each with the chart reference a reviewer needs to confirm or reject it.
clinical documents · rostersClinical Data TransformersStructured, referenced facts from notes, operative reports, faxes and rosters.
Problems we've built for
Two workflows, described as the work.
Prior authorization agentExample run
Arrives
Auth requestwith attachments
Clinical notes40 pages, scanned
Policy criteriaversioned, cited
The agent
Pull through the PHI boundary
Check each criterion
Cite the page for every finding
Assemble the packet
Leaves
Review packetmet · not met · insufficient
Heldfor the medical director
Under CMS-0057-F
Checked against policy, evidenced, decided inside a regulated turnaround, and defensible afterwards.
- Pull the request through a connector that is the PHI boundary
- Check it against the applicable criteria, citing each one
- Route anything consequential to a named clinical reviewer, never auto-deny
- Record what was decided, on what evidence, by whom
Contracting
Credentialing, rate construction and a contract package across several systems and teams, with a compliance floor under all of it.
- Onboard and credential against the systems of record
- Construct rates within the bounds your policy sets
- Assemble the package with every figure traced to source
- Hold it for the contracting lead before anything is sent
Bring us the case that takes the longest.
Show us the case your team assembles by hand. We'll show it assembled, every figure traced, and the decision left with your clinician.
How Kinett worksOne workflow at a time
Proved on your own data before it touches anything.
We don't start with a platform rollout. We start with one piece of work your people do by hand, and it stays off until you've watched it run against your real cases and agreed with what it produced.
The engagement
From one workflow to a governed agent, in four steps.
1
Pick one workflow
One piece of work with a clear trigger and a clear output, usually one where the rules are known and the volume hurts.
You end up holdingA written scope: trigger, steps, systems touched and who signs off.
2
Get the rules out
The logic lives in a legacy screen, a batch job, a spreadsheet, an SOP and the head of someone who has done it for fifteen years.
You end up holdingA versioned knowledge base where every rule cites its source and who confirmed it.
3
Prove it before it acts
The agent runs on your real cases in a sandbox with every side-effect stubbed. You compare its output to what your team did, case by case.
You end up holdingA side-by-side on your own data that you can take to risk and compliance.
4
Turn it on, governed
It goes live inside its limits, with the actions that matter held for a named approver.
You end up holdingA running agent, an approval queue and an audit trail from day one.
The first workflow carries the platform setup with it: connectors, limits, approval routing and the audit trail. Every workflow after that reuses it, so each new one costs materially less than the first: it brings only its own vertical work.
workflow 1
workflow 2
workflow 3
workflow 4
At the end
What you're left holding.
- AgentA running agent, inside limits your administrators set
- KnowledgeThe knowledge base behind it, versioned and yours
- AuditAn audit export your examiner can read, covering every run
- ApprovalsThe approval queue, wired to your named people
- RunbookHow to change it, and who may
- SourceThe source itself, if you licensed it that way
Your vertical
Not finance or healthcare? It may still fit.
Energy · legal · insurance · public sector
If your work runs on documents, rules and sign-offs, it fits.
The runtime, the shield and the audit trail are already built and hardened. A new vertical is the vertical work: its knowledge, its checks and the connectors to your systems.
Pick one workflow. We’ll take it from there.
One piece of work, a clear trigger, a clear output. That's all we need to start.
Talk to usStart a conversation
Start with your workflow, not our platform.
Tell us what arrives on your team's desk that a governed agent should have drafted first. We'll tell you honestly whether it's a good place to start, and if it isn't, which one is.
Before we talk
Three questions worth answering first.
Which piece of work?
One task your people do by hand, with a clear trigger and a clear output.
Which systems does it touch?
Where it reads from and writes to: screens, files, exports, spreadsheets.
Who signs off today?
The person who approves the result, and what they would need to see to trust an agent with it.
Tell us what lands on your desk.
Write to us at contact@mpower4.com. A person on our team reads every message and replies.