The vibe-coded tool
- Lives beside your real systems with its own login and a copy of your data
- Previews, approvals, audit: all yours to build and maintain
- Orphaned the day its builder moves on
The secure kernel for AI-native enterprise software
Software that adapts to you. Safely.
Patchy is built on a governed kernel, the part of your software that never moves. On top of it, AI turns the workflows you actually run into native patches: previewed in plain English, approved by a person, audited, and reversible. Nothing ships blind.
- identity
- permissions
- records
- audit
- policy
- rollback
The problem
Your real workflow doesn’t live in your software.
You bought the tools. The actual process still lives in spreadsheets, DMs, and one teammate’s memory, because the tools can’t bend to how your team actually works. So people build workarounds, and the workarounds quietly become the system.
AI can build the workflow. The missing layer is where it safely lives.
The obvious question
“Couldn’t we just vibe-code this ourselves?”
You could. You’d get an app, and it might even demo well. But it floats beside your real systems with its own login, its own copy of your data, and no rules. Building the workflow was never the hard part. The hard part is the boring, load-bearing stuff around it: permissions, history, previews, rollback. That layer is exactly what Patchy is.
A Patchy patch
- Native to your records, your identity, your permissions
- Previewed in plain English and approved by a person before it goes live
- Versioned, audited, reversible, and still governed when its author leaves
Everyone wants software their team built for itself. Nobody wants to have built it.
What Patchy is
Patchy makes enterprise software a patchable kernel.
The kernel is the part that never moves. It knows who is asking, decides what they may touch, writes the audit record before anything risky happens, and refuses what it cannot trust, no matter who clicks approve.
Everything else is a patch on top.
Kernel
What stays constant: identity, permissions, records, audit, policy, rollback.
Patch
What changes: a field, a view, a workflow, an automation. Built by AI, approved by a person before it goes live.
Runtime
Where AI does its work: a sandbox scoped to the task at hand, on the record like everyone else, with no side doors into your data.
Patches change. The kernel doesn’t. And the sketchy one never gets in.
How it works
Bring one messy workflow. Watch it go native.
No new tool to learn, no code to review. You describe, Patchy patches, you approve. And you can roll it back any time. Think: “track flights across our concierge clients,” or “flag deals that sit untouched for two weeks.”
Describe it
Say it in plain words, mess and all. Patchy asks what matters: who owns it, what data it touches, which edge cases bite.
Approve the plan
You get a business-readable plan, not code. Nothing is built until you say the plan is right. And approving the plan is not approving the deploy.
Patchy builds and tests
The patch is built in a sandbox and checked by the kernel: permissions, data access, safety. All before you ever see it.
Preview. Publish. Or roll back.
A mandatory preview shows exactly what will change, in plain English. A person says yes, and publish is verified against the exact preview you approved.
Day to day
Patches compound. Chaos doesn’t.
Personal patches shape how you work: your views, your shortcuts, that one pet peeve finally fixed. Company patches earn review before they reach everyone. Turn a layer off and the base is untouched.
Share a patch with a teammate. Promote the good ones. When a bigger workflow comes along, new patches build on the ones you already trust instead of starting from zero.
- Personal patches: your views, your shortcuts
- Company patches: shared fields, queues, workflows
- The kernel: identity, permissions, records, audit. Unmoved.
Governance
Generated software becomes company software when it’s governed.
Every patch walks the same path before it can touch the company. Governance isn’t an appendix here. It is the product.
Identity
The kernel knows who is asking, person or AI.
Permissions
A patch only touches what its owner is allowed to touch.
Policy
Risky changes earn extra review. Personal tweaks stay fast.
Preview
Mandatory. You see the change in plain English before it is real.
Approval
A human says yes. AI never auto-deploys.
Audit
The record is written before the risky action happens, not after.
Where we’re starting
First up: your sales team.
Patchy ships today as the sales team’s daily tool: pipeline, contacts, follow-ups, reports. Yes, that means it does what a CRM does. The difference is the kernel underneath, and a tool that reshapes itself around your motion instead of asking your team to bend around it.
Support, ops, finance: same kernel, later. We’d rather make one surface excellent first.
The invitation
Bring your messiest workflow.
We’re onboarding a first, small group of pilot teams, working directly with the founders. The honest shape of it: a call to see if we fit, then we find the pains worth hitting first, then we deploy your Patchy workspace and build the first patches with you. Expect very hands-on help, fast fixes, and the occasional bug. It’s early. Pilot teams get to shape what Patchy becomes.
- A workflow your team actually runs lives in spreadsheets and DMs
- You already spend real money on LLM tokens (patches are built with yours)
- You want a say in what this becomes
