Jeff Huber, the founder of Chroma, published a piece called 12-Factor Companies. It borrows the format from 12-factor apps and applies it to how AI-native organizations will run. It’s written for software companies. But strip away the Silicon Valley framing and the core idea lands harder on subscription commerce than almost anywhere else.
Here it is in one sentence: the company of the past was designed around the bottleneck of human execution. The company of the future is designed around the bottleneck of human judgment.
Think about what your operation actually spends human hours on. Pulling reports. Chasing declined cards. Reconciling numbers between your CRM, your gateway, and your fulfillment system. Watching dashboards. Exporting CSVs so someone can re-import them somewhere else. None of that is judgment. All of it is execution. And execution is exactly the part that agents are getting very good at, very fast.
So we took Huber’s twelve factors and translated the eight that matter for a subscription commerce operation. If you run recurring revenue at real volume, this is what the next version of your business looks like.
Factor 1: Own your context
Huber warns about “context vampires”: vendors who hoard your data to build a moat around themselves. Commerce operators know these vendors well, even if they’ve never used the term. Your platform shows you a dashboard. Your gateway shows you a different dashboard. When you want the underlying data, you get a CSV export with half the fields missing.
That data is your context. Every transaction, every decline code, every retry, every cancellation reason. It’s the record of how your customers actually behave, and it’s worth more than any single feature of any single tool. A platform that keeps it locked behind reports it designed for you is charging you rent on your own business.
The test is simple: can you run any query you want against your own data, right now, without asking anyone? If the answer is no, you don’t own your context. Your vendor does.
This is why RevCent puts every account on a full data warehouse from day one. Not an export button. A warehouse: every transaction, subscription, salvage attempt, and tracking event, queryable with plain SQL by you or by any agent you point at it. Your context, forward from the day you start writing it.
Factor 2: Rent your intelligence
The opposite rule applies to the AI models themselves. Don’t marry one. The model that’s best today will be second-best in six months. The winners in this cycle will be operators who can swap intelligence like they swap a supplier: same operation, better brain.
The way you keep that option open is a standard interface between your business and whatever model you’re using. That’s what MCP is: an open protocol that lets any capable agent call into your systems and do real work.
This is why RevCent is built AI-agnostic on purpose. We don’t ship our own model, and we don’t lock you into anyone else’s. RevCent’s MCP server exposes over 250 operations (creating a subscription, running a warehouse query, firing a salvage sequence) and any capable agent can call them. Claude today. OpenAI’s agents tomorrow. Whatever wins next year, the day it wins. The backend doesn’t know or care which brain is on the other end, and that indifference is your leverage: when a better model ships, your operation upgrades in an afternoon, with zero migration.
Own the context. Rent the intelligence. Never the reverse. An operator who rents their context and owns nothing but a model subscription has it exactly backwards.
Factor 3: Buy your infrastructure
Huber’s line: don’t build your own database or operating system. The commerce translation is sharper, because the stakes are higher. Never build your own payments infrastructure.
PCI Level 1 certification, card vaulting, gateway integrations, network compliance. This is a full-time engineering organization’s worth of work, it produces zero competitive advantage, and getting it wrong is existential. The same goes for telephony, for data warehousing, for AI model hosting. These are commodities. Buy them from people whose entire business is doing them right.
The point of buying infrastructure isn’t laziness. It’s that every hour not spent rebuilding a solved problem is an hour spent building the thing that actually is unique: your offer, your funnel, your recovery logic, your judgment.
Factor 4: Build your tools
Which brings us to the other side of the line. Your tooling is the specific logic of how your business handles a decline, routes a transaction, treats a longtime customer differently from a new one. That you should own completely.
The old way to “own” this logic was to write it into a standard operating procedure and hope your VA followed it. Or wire together five SaaS tools with a workflow platform in the middle, and pray none of them changed their API. Both versions put your business logic somewhere fragile: a person’s head, or a subscription you don’t control.
The new way is code. Small, focused functions that run inside your commerce backend, trigger on real events (a decline, a rebill, a cancellation) and execute your logic exactly the same way at 3 AM as at 3 PM. RevCent’s Functions runtime exists for precisely this. Your salvage cadence, your routing rules, your customer-treatment logic: written once, versioned, and running where your data already lives.
Buy the rails. Build what runs on them.
Factor 5: Hire agents before people
This is Huber’s bluntest rule and it translates to commerce with no modification: before you hire a person for a task, first try to teach an agent to do it.
Before you hire a retention rep, point an AI voice agent at your declined cards. Before you hire an analyst, let an agent query your warehouse and bring you the answer. Before you hire an ops coordinator to watch for failed rebills, write a function that watches for them and acts.
Notice what this rule doesn’t say. It doesn’t say fire your team. It says the default for new execution work has flipped. Headcount used to be the only way to add capacity; now it’s the expensive fallback for the work agents genuinely can’t do: the judgment calls, the taste, the relationships.
And the beauty of commerce is that this experiment scores itself. When an agent works declined cards, the result isn’t a vibe. It’s recovered rebills you can count, and the forward revenue attached to them. We call that metric Saved LTV: the subscription revenue that would have walked out the door and didn’t. You don’t have to trust that the agent is working. You can query it.
Factor 6: Store and learn from production traces
Huber’s most underrated factor. Agents improve by learning from their own real execution: not from theory, from traces.
Most commerce stacks throw this gold away. A retry fails, the failure vanishes into a log nobody reads, and the next retry makes the same mistake. But if every salvage attempt, every cascade decision, every voice-agent call is recorded as structured, queryable data, then your operation has a memory. Which decline codes recover on the second attempt but never the fifth? Which gateway approves the transactions another one refuses? What did the customers who took the voice agent’s call have in common?
Those answers are sitting in your traces. An operation that stores them can ask; an operation that doesn’t is guessing. This is the quiet payoff of Factor 1: owning your context isn’t just about access, it’s about accumulating the raw material your future improvements are made of.
Factor 7: Encode your expertise
Every operator carries a playbook in their head. Which declines are worth working hard. When to offer a discount versus a pause. Which customers get the white-glove treatment. Nine times out of ten, that playbook lives nowhere else. And when the operator is on a plane, the playbook is on the plane too.
Tribal knowledge doesn’t scale and doesn’t survive. The fix is to write it down in a form that executes: your decline logic becomes a function, your save-offer rules become agent instructions, your definitions of a good customer become queries. Encoded expertise runs at full quality on every transaction, every time, whether you’re watching or not.
There’s a second payoff. The act of encoding forces you to make your own thinking explicit. And half the time, writing the rule down is the first time you notice the rule is wrong.
Factor 8: Build a compounding learning machine
Huber’s closing argument is that the companies that win will simply learn faster than their market. Put the previous seven factors together and you can see the machine:
You own your data (Factor 1), so every outcome is recorded (Factor 6). Your logic is encoded and versioned (Factors 4 and 7), so when the traces reveal a better rule, you change one function, not a training manual, not a team habit. Agents execute the new rule instantly and uniformly (Factor 5), on infrastructure you didn’t have to build (Factor 3), with intelligence you can upgrade the moment something better exists (Factor 2).
That’s a loop. Observe, adjust, deploy, observe again, with cycle times measured in days, not quarters. An operation running this loop doesn’t just perform better this month. It widens the gap every month, because its improvement rate is the thing that’s improved.
The judgment business
None of this removes the operator. It promotes you.
Every hour the old stack spent on execution (the reports, the retries, the reconciliation) was an hour stolen from the work that actually compounds: reading the numbers, making the calls, deciding what the machine should do next. The eight factors don’t automate your business. They automate the part of your business that was never supposed to need you.
Every platform has a dashboard. The question that will sort commerce operators over the next few years is different: does your backend have anything your agents can operate?