by floatboat | 2026-02-25 16:00:19+00:00
AI agents are improving rapidly.

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.