Contract Review & Renewal OS
An operating layer that reads supplier contracts, flags risk and renewal dates, and drives renewals before they auto-roll against you.
Where value leaks today.
Supplier contracts live everywhere except where you can act on them — a signed PDF in someone's drive, a clause buried on page nine, a renewal date in a calendar that left with the employee who set it. The work of reading them falls on whoever has time, which means it mostly doesn't happen. Auto-renewals trip silently, price escalators compound, and unfavorable terms survive for years because no one re-read the paper they were signed under.
A contract repository promises to fix this and mostly just files the PDFs more neatly. Storage isn't the gap. The gap is comprehension and timing: knowing what a contract actually obligates you to, where it diverges from your standard, and when the window to renegotiate opens and closes. A repository can tell you a contract exists. It can't tell you it's about to auto-renew at a 7% uplift you could have contested.
So renewals get handled reactively, at the worst possible leverage point — days before expiry, with no benchmark and no alternative lined up. Value leaks not through bad negotiation but through absent negotiation. What's needed is a system that reads the portfolio continuously, understands each agreement's terms and clock, and brings the right renewal to a human while there's still room to move.
One governed flow — agents act, you approve what matters.
Every supplier agreement is read, benchmarked, and brought to a decision before its renewal window closes, with humans negotiating from leverage instead of a deadline.
One operating layer — eight governed jobs.
Each is a governed agent inside the same system, sharing context — not eight tools you stitch together.
Contract Ingestor
Collects executed agreements from drives, email, and signature tools into one governed corpus. Ends the hunt for which PDF is the signed version.
Clause Extractor
Parses each contract into structured terms — pricing, liability, termination, renewal mechanics. Turns dense paper into queryable obligations.
Deviation Analyst
Compares extracted terms against your standard playbook and flags where a contract diverges. Surfaces the clauses worth a human's attention, not all of them.
Renewal Clock
Tracks notice periods and auto-renewal dates across the portfolio and raises each one with enough lead time to act. Kills the silent auto-roll.
Price Escalation Watcher
Detects built-in uplifts and indexation clauses and projects their cumulative cost. Shows what a quiet renewal actually costs over its term.
Obligation Tracker
Maps your ongoing commitments — volumes, SLAs, exclusivity — and monitors whether they still fit. Prevents you from being bound to terms you've outgrown.
Renewal Briefer
Assembles a decision pack per renewal: current terms, deviations, spend history, and a recommended path. Gives the human leverage instead of a deadline.
Notice & Redline Drafter
Generates termination notices, renewal confirmations, or redlines aligned to the chosen path. Executes the decision instead of leaving it as a to-do.
Autonomy you can trust — because the control is built in.
The system acts on its own and every action stays legible, bounded, and reversible. You don't choose between speed and control; the control is what makes the speed safe.
Legible
See what was done, what was declined, and exactly what's waiting on you — nothing happens in a black box.
Bounded
Agents act only within the rules you set. Anything material or irreversible stops at a human gate.
Reversible
Every action is logged and undoable. A wrong turn is caught and rolled back, not discovered weeks later.
Owned
One operating system you own — not a swarm of rented agents you have to police. Built, run, accountable.
Every supplier agreement is read, benchmarked, and brought to a decision before its renewal window closes, with humans negotiating from leverage instead of a deadline.
What you're actually getting.
Is this a product or a build?
A build. Kitsune forges the review-and-renewal layer around your contract stores, standard playbook, and signature stack — it learns your standard positions rather than imposing a vendor's.
What stays in my control?
Every renewal decision — renew, renegotiate, or exit — is a human gate. Agents read, flag, and draft; they never commit you to a term.
How is this different from a contract repository?
A repository stores the PDF. This system understands it — what it obligates, where it deviates from your standard, and when the window to act opens — and then drafts the move.
Can it stop auto-renewals from slipping through?
Yes. The renewal clock tracks every notice period and surfaces it with lead time, so nothing rolls over before you've chosen to let it.
Does it handle our non-standard legacy contracts?
It extracts terms from whatever you actually signed, structured or not, and flags how each diverges from your current standard so old paper stops hiding bad terms.
The same foundry, other domains.
Bring us the bottleneck.
We'll forge the operating layer around your friction — built, owned, and running.