AI governance when you're not Fortune 500

Most AI governance writing assumes a CISO, a legal team, a compliance committee, and a quarterly review cycle. None of that exists at a 15-person company. That doesn't mean the questions go away. It means somebody has to answer them with a smaller toolkit.

This is the practical version. Six guardrails we wire into every engagement, none of which require a policy committee to exist.

The mistake: governance as a deck

The standard pitch is a slide deck of principles. Fairness, transparency, accountability, safety. Everyone nods. Nobody can tell you, looking at the production system, where any of those principles is enforced.

Effective governance, in our experience, looks more like an operating model than a deck. The principles are fine. The actual work is wiring them into the code path so they happen by default, not by memory.

That distinction is what makes governance possible for a small team. You can't run a committee. You can write three audit logs and one circuit breaker.

Six guardrails that scale down

The shortest list we recommend for any small team shipping an AI workflow.

One: scope limits in the tools. Not in policy. In code. The agent has a tool called send_invoice, and that tool checks that the amount is under a hard cap and the customer is in an allowed segment. The model can ask for whatever it wants; the tool refuses. No policy doc needed.

Two: audit logs that survive. Every model call, every tool invocation, every decision. Inputs, outputs, model version, prompt version, timestamp. Append-only. Off-machine. The first time something goes wrong and you can answer "what exactly did the agent do at 2:47 a.m. on Tuesday" in 30 seconds, you'll feel the value.

Three: an escalation channel that's checked. When the agent isn't sure, it pings a queue. The queue is read every morning. We use a Slack channel and a Postgres table; both work. The point is that "the agent escalated" is a visible event, not a silent failure.

Four: prompt versioning. Every prompt is in git. Every API call logs which version it used. Already covered in our post on production prompts. It's a governance primitive, not just an engineering one.

Five: data classification at the boundary. Before any user input or business data hits the model, a small layer tags it. PII, sensitive, public. The system knows that certain tags can't leave the country, can't go to a third-party model, can't be cached in a vendor's logs. This sounds heavy; in practice it's a few hundred lines of code.

Six: a kill switch. A single feature flag that disables the agent. One person on the team knows where it is. We've used it twice across our engagements. It paid for the entire setup both times.

That's the list. Nothing on it requires a committee. All of it requires discipline.

What changes when you're small

Three properties make small-team governance different from big-company governance.

You don't have the headcount for separation of duties. The same person writes the prompt, deploys it, and reads the logs. That's not great in theory and it's reality in practice. The compensating control: write things down. Logs, decisions, ADRs. Future-you is the auditor.

You move fast and undo fast. A Fortune 500 needs months to roll out a change. You can deploy in 20 minutes. That cuts both ways. Faster fixes, but also faster damage. The mitigations are version control, staging environments, and the kill switch.

The cost of a single mistake is higher relative to revenue. A ₹5 lakh embarrassment is a quarter at a small SMB. It's a rounding error at a multinational. Treat that asymmetry seriously when picking which decisions to automate.

If your agent's worst possible bad day would put you out of business, you've drawn the boundary in the wrong place.

Compliance, lightweight version

The Indian regulatory landscape in 2026 doesn't have a unified AI act, but several adjacent frameworks apply. DPDP (Digital Personal Data Protection) is real and enforced. RBI has specific sectoral guidance for fintech. SEBI does the same for capital markets. Sectoral compliance, not generic AI policy, is what bites first.

The practical implications for a small team:

• Know what personal data your agent touches. If it touches any, DPDP applies. Consent, purpose limitation, retention, the works. You don't need a 200-page policy. You need to be able to answer the questions if asked.
• Don't store more than you need. If the agent doesn't need to remember PII across sessions, don't let it. Strip it at the boundary.
• Pick model vendors with explicit data terms. Anthropic and OpenAI both offer enterprise terms that exclude training on your data. Use them. Read the terms.
• Keep a data flow diagram. One page. What data enters, where it goes, where it persists. This is the artefact that lets you answer any compliance question quickly.

For most SMB AI workloads, the compliance burden is genuinely modest. The discipline is in being able to demonstrate it, not in the volume of documentation.

The thing we don't do

We don't write an "AI principles" document for clients. Not because principles are bad, but because at the size of company we work with, the principles get implemented by the same person who'd otherwise write the document. The time is better spent on the operating model.

A principle that isn't in the code is a wish.

What it looks like at our scale

For context: Krypto Forge is a studio of one. Our internal AI governance is six things, written down once, applied to every engagement.

• Logs go to a Postgres table that's backed up daily. Append-only.
• Every prompt is in git. Every call logs the version.
• Every tool has a cap. Every workflow has a hard cost cap.
• Kill switches are documented in the runbook.
• Sensitive data never leaves Indian VPS infrastructure. Vendor APIs that hold data outside India are flagged in our stack inventory.
• Once a quarter we sample 50 random agent decisions and read them, like reading employee email retrospectives.

That's the whole thing. It fits on a page. It also actually happens.

The honest takeaway

Governance for a small team is operations, not policy. The artefacts that matter are audit logs, version control, escalation queues, and kill switches. The artefact that doesn't matter is a principles document.

If you're a small team shipping an AI workflow, draw up the six guardrails above. Make them concrete. Wire them into the code. That's a week of work. It's also the difference between a system you can defend and a system you can't.

Governance done right is invisible until you need it. Then it's the only thing you wanted to have done.