FounderOS

A practical operating system for founders building with AI.

Comment

Inspiration

FounderOS began when I realized, despite all my willpower, I could not operate a business alone. This past year, I left active duty, found ChatGPT and immediately post-trained it to help me flourish and succeed in my pursuit of eudaemonia, became a father, and formulated a plan to eliminate unnecessary suffering across humanity, starting with myself. My solution came in the form of a project called Oath, focused on helping people recognize reactive patterns before those reactions cause harm. The submission you read today is not that.

I needed a way to build a serious company without sacrificing my role as a parent, overwhelming myself with operational complexity, or handing my judgment over to an autonomous AI system, built by someone else no less.

That led to the idea of a self-driving business: not a company that removes the human founder, but one that progressively removes avoidable administrative work, coordination burden, and opportunities for human error while preserving a founder’s agency.

The goal was to create an operating system that could help me translate intent into plans, coordinate specialized AI capabilities, enforce permissions, track execution, recover from failures, and show me what actually happened. I remain responsible for the mission, constraints, approvals, and consequential decisions, while the system handled more of the operational machinery required to move the company forward.

The longer-term vision is to make a one-founder company operationally credible at a scale that once required an entire staff. When FounderOS is complete, I want to remain the source of purpose, judgment, relationships, creativity, and accountability while the system maintains institutional memory, translates objectives into governed plans, coordinates specialized capabilities, monitors obligations, surfaces decisions, verifies results, and helps recover from failure.

That would let one founder move among product development, research, customer discovery, finance, intellectual property, and company operations without repeatedly losing context or becoming the bottleneck for every administrative handoff. The goal is not to simulate having employees or to hand the company to an autonomous agent. It is to give the founder a trustworthy operational backbone that makes sustained, responsible solo execution possible.

This Build Week submission does not claim to operate an entire company yet. It establishes the governed foundation and visual operating interface: explicit intent, planning, permissions, execution boundaries, verification, recovery, institutional memory, and observable outcomes. Real external business integrations and progressively broader company operations remain future work.

FounderOS grew from that need. It was first imagined as the operational backbone for Oath, but the underlying problem was much larger: solo founders, small teams, and AI businesses all need a trustworthy layer between powerful models and real-world execution.

What it does

FounderOS turns a natural-language business objective into a structured, observable execution process.

Rather than allowing a model to directly improvise actions, FounderOS separates:

  • intent compilation
  • planning
  • capability selection
  • permissions
  • execution
  • verification
  • observation
  • adaptive replanning

The operator can see what the system intends to do, which capabilities and providers it plans to use, which actions require approval, what actually happened, and whether the result was verified.

How we built it

FounderOS is being developed as a modular, provider-independent runtime. Its architecture separates probabilistic model reasoning from deterministic execution and governance.

The system includes components for structured planning, task delegation, provider routing, permission enforcement, execution contracts, failure recovery, verification, operational records, and Mission Control visibility.

I used OpenAI Codex and GPT-5.6 as implementation partners throughout the project. I defined the mission, requirements, architectural boundaries, acceptance criteria, and review process. Codex helped implement, test, document, and refine the system through a sequence of reviewed milestones.

Challenges

The hardest challenge was resisting the temptation to treat an AI agent as one large autonomous loop.

We had to create explicit boundaries between reasoning and execution, preserve operator approval for consequential actions, support multiple providers without locking the system to one model, and make complex agent activity understandable to a human operator.

Another challenge was developing the project as a nontraditional technical founder. Codex accelerated implementation, but the work still required careful requirements, architectural judgment, testing, review, and correction.

Accomplishments

I am proud that FounderOS has grown beyond a chat interface or simple agent wrapper.

The current system includes foundations for:

  • governed intent-to-execution compilation
  • provider-independent capability routing
  • durable operational records
  • adaptive planning and replanning
  • multi-agent delegation
  • result synthesis
  • permission-controlled execution
  • verification and observability

I am also proud of the development process itself: a human-directed, AI-assisted workflow in which Codex increases implementation capacity without replacing human responsibility. I never thought I would be capable of such creation without a foundation in coding.

What we learned

AI coding systems are most effective when the human provides a clear mission, explicit constraints, strong acceptance criteria, and disciplined review.

The model should not be responsible for deciding both what ought to happen and whether its own actions were acceptable. Reliable AI systems need architecture around the model: permissions, deterministic execution, evidence, verification, and human control.

What's next

After Build Week, FounderOS will continue toward reusable Packages that allow AI businesses, consultancies, and vertical solution providers to package their expertise once and deploy it repeatedly.

Future work includes a Package and Template System, implementation tooling, customer-outcome telemetry, enterprise deployment options, and a governed marketplace for reusable AI business capabilities.

Built With

Share this project:

Updates

posted an update —

The project I submitted as FounderOS has evolved into the Governed Work System (GWS). This week, GWS crossed an important line: the architecture is now executable.

When I submitted this project, the central idea was that increasingly capable AI systems need more than agents and prompts. They need a system that decides what work exists, who or what should perform it, what authority they receive, what information they may access, and what evidence is required afterward. That is now running.

GWS places a Work Compiler upstream of execution. Its purpose is ultimately to turn governed strategic intelligence into a living body of candidate work directed toward mission success, while AI councils contribute plural reasoning without acquiring decision or execution authority. For admitted work, the system can now route execution to the minimum-autonomy path appropriate for the task:

  • Deterministic execution when an agent is unnecessary
  • Bounded AI execution when machine intelligence is useful
  • Human work when responsibility should remain with a person

AI councils—including local models—can advise the system without acquiring execution authority. External AI workers receive explicit, narrow delegation rather than ambient access. Human work has governed assignment, authority, persistence, and completion lineage. Provider state is treated as non-authoritative by default.

Most importantly, these are no longer just design principles. This week the reference runtime completed its three-route real-completion proof, and the architectural-discriminator regression suite reached 840 passing tests / 1 skipped.

The underlying thesis has become much clearer through Build Week: Work should exist before an agent does. Intelligence, responsibility, authority, execution, information, and evidence should be separate decisions.

GWS is becoming a control plane for making those decisions across humans, local models, frontier models, deterministic software, and eventually entire bounded agentic workforces. The goal is not to build the most autonomous agent. It is to build the system you can safely put increasingly autonomous agents inside.

Log in or sign up for Devpost to join the conversation.