What hasn’t improved is the file.
We still exchange `.docx`, `.pdf`, `.pptx`, `.md`, and links to SaaS platforms — formats designed for GUI software, not autonomous systems.
Agents can generate content. Agents can refactor code. Agents can orchestrate workflows.
But agents cannot reliably exchange full working context through files.
We built *Selfware* to explore a simple idea:
> What if a file was a self-contained execution unit?
---
## The Problem
A modern AI workflow often looks like this:
* Agent A researches * Agent B formats * Agent C validates * A human reviews
But the “handoff” between them usually degrades to:
* Flattened text * Lost reasoning traces * Manual prompt reconstruction * Platform lock-in
Traditional file formats store data.
They do not store:
* Execution context * Structured memory * Change intent * Agent-readable state
And proprietary formats (Excel, PowerPoint, PDF) are not designed for autonomous modification.
The result: agents operate with partial visibility.
---
## The Idea
Selfware defines a minimal file protocol where:
* A file contains its own canonical data source * Views are projections, not authorities * Structured memory is first-class * Execution logic can be embedded * Collaboration is optional but native * Everything runs locally by default
A `.self` file is simply a ZIP container.
Inside it:
``` project.self/ ├── manifest.md ├── content/ │ ├── project.md │ └── memory/ │ ├── changes.md │ └── decisions.md ├── views/ ├── runtime/ └── skills/ ```
Key constraints:
* Only `content/` is writable canonical data * Views are disposable projections * Memory is structured and inspectable * No silent remote mutations * Git-compatible history * Optional: contains agent-executable skills or plugins
The goal is not to replace Markdown.
The goal is to make a file capable of carrying:
* Data * State * Context * Collaboration metadata * Execution scaffolding
In one portable unit.
---
## What This Enables
### 1. Agent-to-Agent Continuity
When one agent finishes work, it can record:
* Decisions * Logs * References * Structured context
Another agent can pick it up without guessing.
The file becomes a handoff boundary.
---
### 2. “Living” Files (Optional)
If configured with a Git remote, a `.self` file can:
* Check for updates * Show diffs * Require explicit approval * Merge changes
No SaaS required.
---
### 3. View as Function
A single canonical source can render as:
* Document * Slide deck * Outline * Card UI
Because views are functions of data — not separate artifacts.
---
## What This Is Not
* Not a new productivity app * Not a cloud platform * Not a proprietary ecosystem * Not a replacement for Git * Not an attempt to centralize agents
It’s a protocol experiment.
---
## Design Principles
1. Single-File Authority 2. Explicit Mutation Only 3. Local-First Execution 4. Structured Agent Memory 5. Open Specification (MIT)
The specification draft is open. The container format is trivial. The runtime is minimal.
We’re interested in feedback on:
* Failure modes * Security concerns * Spec simplifications * Alternative boundary definitions * Whether this should even exist
---
## Why Explore This?
We moved from:
Software → SaaS
Now we are moving toward:
Software → Agents
But we never redesigned the file layer.
If agents become long-lived collaborators rather than tools, they need a stable, portable unit of exchange.
Selfware is an attempt to define one.
---
## Status
* Spec draft v0.1 * MIT license * Minimal runtime prototype * Designed to be forked
If this is flawed, we’d like to know why.
If it’s useful, we’d like others to break it.