The Fork Tax: What Per-Customer AI Policy Is Costing Your Roadmap
By Skyrelis ·
Short answer: The fork tax is the recurring engineering cost of keeping customer-specific AI agent rules in application code as flags, config branches and forks. It shows up as slower releases, a test matrix that keeps growing, and inconsistent enforcement. The fix is to separate what the agent can do (code) from what each tenant allows it to do (policy), and evaluate that policy at runtime.
Nobody plans to maintain a separate version of their product for every customer. It happens one reasonable request at a time. If you ship agents inside your product and sell to enterprises, you’re probably already paying.
How does one product become N products?
Illustrative scenario, not a description of any real company.
- Customer one requires that the support agent never touch records outside their region, and that refunds above a threshold need manager approval. You add a check in the tool layer behind a flag,
enterprise_a_refund_rules. - Customer two wants a different threshold, a different approver and no access to one CRM field. The flag becomes a config block, and the config block grows conditionals.
- Customer three is regulated and wants human review of every agent action. Config can’t express that, so someone cuts a “temporary” branch.
- By customer five, planning isn’t asking “what does the agent do?” It’s asking “which version of the agent do you mean?”
None of those steps was a mistake. Each was the fastest way to close a deal. But they compound, and the rules end up where they’re hardest to see: scattered through application code.

What does per-customer AI policy actually cost?
The costs land in five places:
- Engineering capacity. Every customer-specific rule needs someone who understands both the rule and its code path. That knowledge sits in a few heads, and those people stop working on the shared product.
- A test matrix that outgrows the team. Each flag multiplies the states a release can be in. You test the combinations you remember, and a customer finds the ones you forgot.
- Inconsistent enforcement. One intent, “no refunds above the limit,” gets implemented three ways in three tool wrappers. One rounds before checking and one after. The policy the customer was promised and the policy in production quietly drift apart.
- Slower releases. Every shared-code change has to be checked against every fork and flag it touches. Teams start shipping less often, or freeze the areas where customer rules live.
- Audit difficulty. Ask what rules applied to a tenant last quarter, and the honest answer involves reading code, flag history and branch logs. That isn’t evidence. It’s an investigation.
Add it up and you get the fork tax: a recurring charge on every future feature, paid in engineering time, to keep past deals working.
What is the alternative to per-customer feature flags for AI agents?
The alternative is tenant-scoped policy evaluated at runtime: one codebase, many policy sets. The agent’s code defines capabilities, such as looking up orders, issuing refunds and updating records. A policy layer defines the conditions under which each capability may run. Those conditions are data, scoped to a tenant, and are evaluated when the agent calls a tool or API.
For each action, the layer checks who the agent is acting for, what it’s trying to do, where the call is going, with which parameters, and for which tenant. It returns allow, block or escalate. Customer A’s region restriction, customer B’s approval threshold and customer C’s review-everything profile become three policy sets against one codebase.
Rules are designed to change without redeployment. An updated customer requirement can then be a versioned, attributable policy edit instead of a release. Every decision is logged against the tenant and rule that produced it, which gives you a record to bring to a customer’s review.

This is also the evidence posture buyers now ask for in security reviews — see What Your Buyer’s Security Questionnaire Is Actually Asking About Your Agents.
What belongs in the application, and what belongs in a policy layer?
The test is simple: if a rule exists because a particular customer, region or compliance profile asked for it, it’s policy. If the product needs it to work, it’s code.
| Keep in the application | Move to the runtime policy layer |
|---|---|
| Product behavior and agent capabilities | Which actions are allowed per tenant, role or region |
| Prompts, workflows and user experience | Parameter limits such as amounts, record counts and destinations |
| Business logic that’s the same for every customer | Approval requirements for high-risk actions |
| Which tools and data sources an agent may reach | |
| The decision log that records all of it |
How do you migrate off per-customer flags and forks?
You don’t need a rewrite to start.
- Inventory the flags and branches. List every customer-specific condition that touches an agent action. Group them by what they control: access, limits, approvals or data scope.
- Find the duplicates. Several flags will express the same rule with different numbers. Collapse them into one policy with per-tenant parameters.
- Start with the riskiest actions: money movement, deletion and cross-tenant data access. Leave cosmetic flags alone.
- Run in observe mode. Evaluate the new policy alongside the existing flags and log where they disagree. Each disagreement is a bug you now know about.
- Cut over one rule at a time, then delete the flag. A flag you keep “just in case” is a fork you’re still paying for.
Where Skyrelis fits
Skyrelis is a runtime policy layer for AI agents. It runs inline between agents and the models, tools, APIs, and data they reach, evaluating each action against centrally managed policy before it executes. It deploys without SDKs or changes to agent code and works across models, clouds, and agent frameworks. Capabilities include prompt injection detection, sensitive-data redaction and exfiltration controls, tool and API action governance with human approval gates, token usage controls, contextual risk scoring, and alerting and escalation. Policies are defined per agent, per customer, and per action, can run in monitor, alert, redact, block, or require-approval modes, and can be simulated before enforcement. All agent actions and policy decisions are recorded in an audit trail.
FAQ
What is the fork tax in SaaS?
It’s the recurring engineering cost of maintaining customer-specific rules as flags, config branches or forks, paid in slower releases, bigger test matrices and inconsistent enforcement.
How do you support different AI policies for each enterprise customer?
Store each customer’s rules as tenant-scoped policy and evaluate it at runtime against one shared codebase, rather than coding each customer’s rules into the application.
Should AI agent permissions live in application code?
Capabilities belong in code. Customer-, region- or compliance-specific limits on those capabilities belong in a runtime policy layer.
How do you migrate from feature flags to a policy layer?
Inventory the flags, collapse duplicates, start with high-risk actions, run the new policy in observe mode alongside the flags, then cut over and delete one flag at a time.