Freedom Through Autonomy: Businesses That Run Themselves

I chased the wrong definition of freedom for years.

I wanted “financial freedom,” enough money to stop working. I romanticized “location independence,” the laptop on the beach. I chased “time freedom,” escape from the calendar.

Those are symptoms, not the disease.

The real prison isn’t your location, your schedule, or your bank account. It’s dependency. Dependency on your constant attention. Dependency on your decisions. Dependency on you being the critical path for everything that matters.

Freedom doesn’t come from working remotely. It comes from building something that runs without you.

The paradox of control

Here’s what nobody told me about entrepreneurship: the more you control, the less free you are.

Every decision that requires your input is a chain. Every process that needs your oversight is a tether. Every customer interaction that demands your presence is a cage you built yourself.

Traditional business advice says to “work on your business, not in it.” That’s still wrong. The goal isn’t to hover above the business, managing from a higher altitude. The goal is to build a business that doesn’t need you hovering at all.

For a founder with a team, that means pushing decisions down and hoping they stick. For a founder working alone, which is me, it’s starker. There’s no one to delegate to. Every dependency on me is a dependency on one person’s hours, attention, and health. Either the system carries the load or nothing does.

That’s what I mean by autonomy. Not “my people make decisions while I remain the final arbiter.” That’s distributed dependency: the chains are spread around, but they still connect back to you. Real autonomy means systems that make good decisions without you, and keep making them when you’re not looking.

What “autonomous” actually means

Let’s be precise about the word.

In the context of a business, autonomous means:

Self-directed. The system notices what needs doing without being told each time.
Self-correcting. When something breaks, the system catches it before you do, or at least before a customer does.
Self-improving. Performance gets better through feedback loops, not through your quarterly resolutions.

Notice what’s missing. You.

Not because you’re irrelevant. Because you’ve built something that runs correctly when you’re absent, which is a higher bar than running correctly when you’re present.

The inflection point

For most of business history, this was impossible past a certain point.

You could delegate. You could write procedures. You could hire smart people and get out of their way. But someone human had to make the judgment calls, watch the dashboards, and notice when things trended wrong.

What changed is that agents can now carry a meaningful share of that judgment. Not all of it. Not the parts that matter most. But enough of the routine kind, the “is this ticket a bug or a question,” the “does this change break the build,” the “did this page ship with a claim we agreed not to make,” that a single person can run systems that used to need a staff.

I run a dozen ventures alone, and that is only possible because most of them barely need me on a normal day. Most of them are also early: two are live, and the rest range from private beta to in development, which you can see for yourself on the ventures page. I’m not describing a fleet of finished businesses humming along. I’m describing a way of building that starts with the question: what would this need from me every week, and how do I get that number down before I build anything else?

The cost of the manual override

A thought experiment. What if every decision you made in your business cost you $1,000?

Not because the decision itself costs money, but as a forcing function. Every time you’re about to decide something, you’d have to ask: should this decision even require me?

Most founders are decision addicts. We’ve built our identities around being the person who makes the call. We confuse being needed with being valuable.

But every decision you make manually is a decision you’ll make again. And again.

The refund you decide case by case? You’ll decide it a thousand times.
The prompt you retype instead of saving as a reusable skill? You’ll retype it every session.
The pricing tweak you make after a competitor moves? You’ll make it every quarter.

Manual decisions don’t scale. Manual decisions are expensive. Manual decisions keep you trapped.

The alternative is to write the rule down, encode it, and let the system apply it. Then intervene only when the rule is wrong.

Building for absence, not presence

Traditional planning asks: “What do we need to succeed?”

Autonomous planning asks: “What would this business do if I disappeared for a year?”

This isn’t planning for failure. It’s planning for independence.

Start with constraints:

What if you couldn’t check messages for six months?
What if every process had to be asynchronous?
What if you couldn’t override an automated decision by hand?
What if the business had to fund itself from day one?

These are design constraints, and they force a certain architecture.

I design for absence and I usually get it wrong the first time. The test I use is simple: after a venture has been running for a month, I look at everything I did for it that month and ask which of those things I could have written down as a rule. Anything I could have, I try to turn into one before I touch the venture again.

The three levels I actually run

Not all automation is equal. Here’s how I think about the levels, and I want to be honest about where the line is between what I run and what I aspire to.

Level 1: Task automation

Replacing repetitive manual work with scripts, tools, or agents. Table stakes. The Stockyard on this site is a good example: it started as 23 listings I added by hand, and it’s now 865, because import scripts pull from public collections and a build-time guard blocks anything that would violate the rules I set. I still decide what sources to trust. I don’t type listings.

Level 2: Process automation

Connecting tasks into workflows that run end to end without a human in the middle. This site’s own deployment is one: every push to the main branch builds the site, runs a content guard that fails the build if a forbidden claim slipped in, and deploys. I don’t watch it. If it fails, I find out; if it passes, I don’t hear about it at all.

Level 3: Decision automation

Encoding judgment calls into rules and letting agents apply them. This is where autonomy actually begins, and it’s where I spend most of my design effort now. An agent that triages incoming work, that reviews a change against a written spec before I see it, that decides which of several tools to use for a job. The judgment is still mine. It’s just written down once instead of exercised a thousand times.

The hard part at this level is deciding when a judgment step has earned the right to run without me. Not after a set number of weeks. When it has been run against real cases often enough to show how often it gets them right, and how often it lets a bad one through. I’ve written up the math behind that, and it’s less forgiving than intuition.

What I don’t claim yet

There are two more levels people like to talk about: systems that redesign their own processes, and businesses that find new opportunities and launch experiments on their own. I’m not there. I’m not sure anyone is, outside of demos. When I get to the point where one of my ventures runs a real experiment I didn’t design, I’ll write about it. Until then, three levels is the honest number.

Most businesses never get past Level 2. They automate tasks, maybe some processes, and keep every judgment call in human hands. That isn’t autonomy. That’s efficient dependency.

The freedom equation

Here’s a formula I use. It’s a model, not a measurement, and its value is in what it makes you notice.

Freedom = (Business Value) × (1 − Your Required Attention)

What this means in practice:

A business worth ten times more that needs 80 hours of you every week gives you less freedom than a smaller one that needs two hours a month.
A “successful” exit with a three-year earn-out is less free than a smaller venture that truly runs itself.
Rapid growth that requires constant firefighting is the opposite of freedom.

The goal isn’t the biggest business. The goal is the business that maximizes your freedom coefficient.

For most founders, that means building smaller, more autonomous ventures. For me, it means building a dozen at once, each designed from the start to need as little of me as possible, and being honest that most of them aren’t there yet.

Freedom from vs. freedom to

Financial independence gives you freedom from a job.

Autonomy gives you freedom to build the next thing.

That’s the difference that matters. I write about five kinds of freedom on my own site: financial, time, mental and spiritual, health and energy, purpose and impact. Money is only the first, and it’s the one entrepreneurship is worst at delivering on its own, because the business that makes the money usually takes the other four.

When a business runs itself, you’re not just free from having to work. You’re free to spend your attention on what actually requires a human:

Designing the next venture
Noticing patterns and opportunities
Thinking strategically without operational noise
Living the life you wanted when you started

Most founders never reach this point. They build a successful business that becomes their new job. Better paid, maybe more fulfilling, but still a job.

I built The Fractary to get out of that trap. Every venture is designed for autonomy from inception, as a constraint I enforce from day one rather than a goal for someday.

The courage to let go

Here’s the hard part. Building an autonomous business requires letting go of the thing that made you successful.

Your judgment. Your expertise. Your ability to make the smart call in the moment.

It means admitting that a well-designed system will outperform your best day, consistently, at scale, without burning out.

That’s terrifying for most founders. Our identity is wrapped up in being the indispensable one. The one who sees what others miss. The one who makes it all work.

That identity is a trap.

Real mastery isn’t being the best operator. It’s being the best architect: designing systems that operate better than you ever could alone, and then stepping back.

The path forward

If you’re still reading, you’re probably one of two people.

The trapped founder. You’ve built something that works, and it owns you more than you own it. You’re tired, and you’re wondering if this is what you signed up for. If you’ve done it alone and you’re past $100K in revenue, The Foundry is a small, free, private group of founders in exactly your position, comparing notes. The founding cohort is forming now.

The aspiring architect. You haven’t built it yet, and you’re determined not to make the same mistakes. You want to design for freedom from the beginning. If you’re a teen, or you have one, Make First is the program I built to take a first business from idea to first sale in a semester, with the “run” stage built in from the start.

For both of you, the path is the same:

Stop building businesses that need you. Start building businesses that run.

That means:

Defaulting to a system over a habit
Designing decision rules, not decision meetings
Measuring success by your declining necessity, not your growing importance
Treating your attention as your scarcest resource
Building with agents as the foundation, not the feature

I call this being AI-native. Not because I’m obsessed with the technology, but because it’s the only way I’ve found to build real autonomy alone.

The ultimate freedom

The businesses that create the most freedom aren’t the ones that pay you the most. They’re the ones that need you the least.

They’re the ventures that run while you sleep, improve while you’re away, and hold steady while you build the next thing.

That’s what I mean by “Freedom through Autonomy.”

Not the freedom to work from anywhere. The freedom to work on anything. Or nothing at all.

Because the best businesses run themselves.

This is the first post in a series on building for the agentic age. Next: The Agentic Age Is Here: What Changes for a Founder of One. The stack I build with is on the Platform page.