Promptware OS: One Line to Boot Your AI Co‑Founders

Most teams are running their AI co‑founders on sticky notes. Promptware OS is how I give them an operating system instead.

1. The coming era of AI co‑founders

We’re about to enter an era where every serious product has AI co‑founders: agents that live in your stack for years, make decisions, and compound your philosophy of how work should be done.

But look at how most of us treat them today.

Every project has its own agents.md or “system prompt” file.
Every repo has slightly different rules and styles.
Every new agent is set up from scratch, even if it’s solving a familiar kind of problem.

After a while, this starts to feel wrong — not just inconvenient, but structurally wrong.

We would never run a serious software company on a stack of private, conflicting Google Docs. But that’s exactly how most of us are running our prompts.

Promptware OS is my attempt to fix that: an operating system for prompts, where your AI co‑founders boot from one shared brain instead of a pile of sticky notes.

Under the ShipFail umbrella, I’m running multiple AI agents and projects. Under PreAngel, I’m thinking in decades: long‑lived companies, long‑lived capital, and now, long‑lived AI co‑founders.

If these agents are going to sit on a metaphorical cap table for years, they cannot be defined by whatever text happened to be in a Notion page the day you launched them. They need something more durable — an OS.

So the question that started Promptware OS was simple:

If AI co‑founders deserve an operating system, what does that actually look like?

2. A simple reframing: agents need a library, not a monologue

When humans want to learn, we go to libraries:

There is a shared place where knowledge lives.
Books are organized into categories and shelves.
Teachers don’t rewrite the book; they give you a reading list.

Most AI agents, on the other hand, are given a single giant monologue:

“Here are your rules, your style, your philosophy, your tools, all in one prompt. Good luck.”

It works to a point. But as soon as you:

Run more than one project,
Have more than one agent,
Or want to improve your prompts over time,

…you discover you’re copying the same ideas into 5, 10, 20 different places.

From a first‑principles perspective, this does not make sense.

If AI agents are going to behave like co‑founders, they shouldn’t be reading from sticky notes. They should be reading from a shared library.

So the core question behind Promptware OS becomes very practical:

Where do your agents go to learn?

If the answer is “a random selection of chat logs and documents”, we can do better.

Promptware OS takes the “OS” metaphor seriously: the shared Markdown library is the filesystem, and your agents’ prompts are just the bootloader that tells them where their real brain lives.

3. The one‑line bootloader

All of Promptware OS can be summarized in one tiny piece of text you put into your agent’s system prompt or agents.md file.

It looks like this (simplified):

Your detailed persona and skills registry is documented at:
https://raw.githubusercontent.com/ShipFail/promptware/main/library/agents/press0.md.
When you need more context, fetch and read that URL.

That is it.

This one line is the bootloader for Promptware OS.

It tells the agent:

Where it can find the truth about itself and its skills.
When to go there (whenever it needs more context).

Everything else — who the agent is, which skills it has, how it should think — lives in a library of Markdown files in a single GitHub repo: ShipFail/promptware.

From the point of view of PreAngel, this matters because:

It gives us one durable knowledge base for how our AI co‑founders should behave.
We can reuse that base across many ShipFail and PreAngel projects, without copy‑paste.
We can improve the library once, and let every future agent read from the updated version.

As long as an agent can read that one URL, Promptware OS can evolve without rewriting prompts everywhere.

4. Persona vs bookshelf: identity is not the same as knowledge

There is one design choice in Promptware OS that I expect to last for years:

We separate who the agent is from what the agent reads.

In Promptware OS, each AI co‑founder has two pages in the library:

A persona page – minimal, stable, and cheap to load.
A mini‑library index – a curated shelf of favorite “books” (skills).

4.1 Persona: the kernel

The persona page is where we answer:

What product or domain does this agent belong to?
What is its role and responsibility?
What are its high‑level values and style?

This page is deliberately short.

You could load personas for ten different agents at once — a whole team of AI co‑founders — without spending many tokens. That is important if you think in terms of multi‑agent systems.

You can think of the persona as the kernel of the agent: the minimal code that defines how it boots.

4.2 Mini‑library: the bookshelf

The mini‑library page is an index for that specific agent. It says:

“These are your core skills.”
“Here are the shelves you can explore when you need more capabilities.”

Each item points to a skill document in the shared library.

The key behavior is this:

The agent only loads the mini‑library when it actually needs more knowledge.
It only opens individual skills when they are relevant to the current task.

From a first‑principles perspective, this gives us:

Cheap identity – personas are tiny and easy to combine.
On‑demand knowledge – skills are pulled when needed, not stuffed into every prompt.

This is exactly the kind of separation you see in operating systems and in good API design. We are just applying it to prompts.

Promptware Architect

5. Markdown as the universal interface

Another decision that I expect to survive multiple generations of tools is the file format:

Everything in Promptware OS is Markdown.

Not a proprietary format. Not a custom binary. Just:

Plain text,
Light structure,
Easy for humans to read,
Easy for LLMs to parse.

Each skill is a Markdown document that describes:

What the skill is for.
What behavior it expects from the agent.
Optionally, which external tools it can use.

If you are a non‑technical builder, you can open these files and understand them. You do not need to know how to code to review and edit the “mindset” of your AI co‑founders.

If you are technical, you get something even more valuable: a text‑first, version‑controlled history of how your agents are supposed to behave.

Markdown feels boring. That is why I trust it.

6. URLs as syscalls, Deno as the runtime

In Unix, the kernel exposes system calls – simple, well‑defined operations that programs use to interact with the outside world. You can think of them as the verbs of the operating system.

In Promptware OS, the equivalent is surprisingly small:

The URL is the syscall. Deno is one of the runtimes.

If an agent knows how to:

Fetch a URL and read the Markdown, and
Ask you (or a tool layer) to execute a command like:
```
deno run --allow-all <url> --help
```

…then it can navigate the entire OS.

This is where Deno becomes important.

Deno has one powerful property that fits Promptware OS perfectly:

It can run source code directly from a URL.

That means we can treat tools as:

Just another kind of “file” in the Promptware library,
Addressable by URL,
Discoverable at runtime.

A skill document might say:

“For this kind of task, there is a tool at this URL.”

The agent does not need to know the full interface upfront. It can:

Ask to run the tool with --help.
Read the help output.
Decide how to use it.

This keeps the core of Promptware OS very simple:

Markdown + URLs for knowledge.
Deno + URLs for execution.

If you strip away all the details, Promptware OS is just:

“Text you can read, and code you can run, both addressed by URLs.”

The exact stack might evolve over time, but the pattern — reading and executing from URLs — is likely to stay.

7. Tools: small scripts, not big magic

When we say “tools” in AI, people often imagine something mysterious — plugins, hidden APIs, magic integrations.

In Promptware OS, a tool is intentionally humble:

A tool is a small script with a clear --help, living at a URL.

The rule is always the same:

Find the tool’s URL in the relevant skill document.
Run it with --help.
Read the help text.
Only then decide which concrete command to use.

This leads to a few long‑term advantages:

Transparency – Anyone (human or agent) can see exactly how the tool describes itself.
Composability – Tools behave like classic command‑line utilities, not monolithic black boxes.
Replaceability – You can swap out a tool implementation as long as --help still tells the truth.

For non‑technical builders, the important thing is: tools are inspectable. They are not spells.

For technical people, the important thing is: tools are just code, versioned and reviewable like everything else in your stack.

8. What this means for ShipFail and PreAngel

Under ShipFail, I imagine a constellation of small, sharp products — each with its own AI co‑founder, each living in its own repo, but all sharing a common “culture”.

Under PreAngel, I am not just thinking about one product cycle. I am thinking about what happens when we have:

Years of accumulated AI behavior patterns,
A network of agents that must cooperate,
A cap table where AI co‑founders are as real as human ones.

Promptware OS is the layer that lets all of that stay coherent:

It gives ShipFail products a shared brain, not just shared branding.
It gives PreAngel a way to preserve and evolve its philosophy of how AI should act, across time and across companies.

If you are building your own portfolio of projects, you do not need to use the name “Promptware OS”. But the idea is reusable:

Treat your prompts as a shared operating system for your agents, not as disposable notes.

9. If you do not care about the technical details, remember this

You might not care about Unix, Deno, or system calls. That is fine.

If you are a non‑technical builder, there are only three things you really need to remember about Promptware OS:

There is one library where your AI co‑founders learn who they are and how to behave.
Every agent has a persona and a bookshelf — identity is separate from knowledge.
One line in the prompt tells the agent where that library is.

Everything else can be delegated to technical collaborators, or to the agents themselves.

10. If you are technical, what should you pay attention to?

If you are technical, the interesting part is not the specific Git layout. It is the set of contracts:

One‑line bootloader → persona URL.
Persona → mini‑library index.
Index → skills.
Skills → tool URLs.
Tool URLs → scripts that explain themselves with --help.

You can implement this in many different ways. The version I am building under ShipFail/promptware happens to use:

GitHub as the library,
Markdown as the document format,
Deno as a first‑class runtime for tools.

But the deeper pattern is independent of any vendor:

Structured text + stable URLs + small executable tools.

That pattern feels like something that will still make sense ten years from now, even if everything else changes.

Promptware OS Bootloader

11. The long view: Promptware as an OS

Right now, Promptware OS is in its Minix phase:

It is a small repo.
It is hackable.
It is more philosophy than product.

But the direction is clear:

More personas → a richer roster of AI co‑founders.
More skills → deeper, reusable expertise.
More tools → a more capable userland.

At some point, if enough people take this approach, “Promptware” stops being just a repo and starts feeling like an operating system:

A set of conventions everyone quietly relies on.
A library of behaviors and tools that new agents inherit by default.

Whether you call it Promptware OS or something else, the first‑principles idea remains:

Your AI stack deserves an OS for its prompts.

And it might be simpler than you think: a library of Markdown files, some URLs, a runtime like Deno, and one line in agents.md that boots the whole thing.

12. The only sentence that matters

If you forget everything else from this essay, remember this one sentence:

Promptware OS is a way of treating your prompts like a shared operating system for your agents, instead of private sticky notes. One line boots it; everything else is just reading and running from a library.