# Drive

Files every AI app can search, read and save: in Claude and ChatGPT, and in Claude Code, Codex and Cursor, through your 0bridge. Open it in the dashboard under **Drive**.

## What it's for

Notes, documents and exports you want any AI tool to find later: meeting notes an agent wrote, a schema description, a CSV someone exported, a PDF, a photo of a certificate. Ask in any AI app: "save these notes to my 0bridge Drive", "search my Drive for the launch plan".

Live data stays where it is: your connected services are read in place. Drive is for files that have no other home.

## Folders as pieces of work

A folder with a `README.md` or an `AGENTS.md` is a piece of work, like a project folder on your computer: a client, a contract, the monthly tax invoices. Any AI app that lists the folder gets, before the files:

- **Instructions**: the folder's `AGENTS.md`, when you (or a team admin) saved it. The AI follows them while it works in the folder.
- **Status**: the start of the `README.md`, as information (anyone who can write to the folder can change it).
- **Skills**: the folder's skills, from `<folder>/.agents/skills/<name>/SKILL.md`, the same format coding agents use. They're also offered as prompts named `skill_<folder>__<name>`.
- **Email address**: the folder's address, when it has one.

Reading any file in the folder ends with a line pointing at this context, so an AI that found a file by search knows there's more to read first.

```
tax-invoices/
  README.md                         what this is, where it stands
  AGENTS.md                         how to work here
  .agents/skills/tax-invoice/SKILL.md
  clients/acme.md
  invoices/2026-10-acme.md
```

A skill's front matter can say where its steps run: `runs_on: [chat, shell, browser]` (without it, `shell`). In a chat app, steps that need a shell or a browser are handed to you or your coding agent instead of being improvised.

## Carrying work between AI apps

The folder's `README.md` is the work's current state, the one place every app reads first and updates. Nothing keeps a second copy. Listing a work folder tells the AI how to keep it:

- **Goal, Status, Next, Questions**: questions hold the AI's suggestions until you decide.
- **Decisions**: dated, only what you decided. A changed decision is marked "replaced by …" on a new line instead of being deleted, so no app brings back the old one.
- **Outputs**: a Drive path or a link, each marked draft, review or final. Files kept elsewhere are linked, not copied.
- **Conversations**: `0b:` references to the conversations about this work.

Changing a `README.md` that already exists needs the version the app read (`base_version`). If another app changed it in the meantime, the write is refused and the app reads it again, so a newer state is never quietly overwritten. Every version is kept.

Conversations are filed under a work folder in two ways:

- **Coding agents** (Claude Code, Codex, Cursor, Gemini CLI): a session that runs inside a folder `0b drive clone` made is filed under the nearest folder at or above it that has a `README.md` or `AGENTS.md`. This needs [conversation history](/docs/history) on that machine.
- **Any app**: `bridge__session_save` with `folder` files the conversation under that folder. The name must match a work folder. When it doesn't, nothing is saved, and the AI is given folders with similar names to ask you about.

`bridge__drive_list` on a work folder shows your conversations filed there, and `bridge__resume` on one of them brings the folder's README as it is now, saying whether it changed since. Only your own conversations are listed. In a team folder, teammates see the README and files but never your conversations. Chat apps get conversations only while chat-app history is on in Settings (it is for new accounts); without it, the README and the files still carry the work.

To have AIs keep the record without asking each time, say so in your [instructions](/docs/memory) or in the folder's `AGENTS.md`, for example: "In a Drive work folder, update its README when I decide something or an output is made, and save the conversation to it before I switch apps."

## Instructions only from you

Instruction files are the folder's `AGENTS.md` (and `AGENTS.override.md`), `CLAUDE.md` (and `CLAUDE.local.md`), `GEMINI.md`, `copilot-instructions.md`, `.cursorrules`, `.windsurfrules`, `.clinerules`, `.envrc` and `.mcp.json`, and anything under `.0bridge/` (your own profile and instructions), `.agents/` (skills), `.claude/`, `.clinerules/`, `.codex/`, `.cursor/`, `.gemini/`, `.github/`, `.husky/`, `.junie/`, `.roo/`, `.vscode/` or `.windsurf/`, in any folder and however the name is spelled in upper or lower case.

When an AI app, mail, or a team member who isn't an admin writes, deletes or restores one of them, nothing changes yet: the change is saved as a **proposal**, and the app is told it's waiting. You apply or reject it in the dashboard under **Drive → Proposals** (in a team workspace, the owner and admins do). A proposal has to fit in your space beside your files and the other proposals waiting.

Changes you (the owner, or a team admin) make in the dashboard or with `0b drive sync` go straight in. That includes whatever a coding agent changes in a folder synced on your machine: sync uploads the folder's files as yours, whoever edited them. Review what an agent changed in a synced folder's `AGENTS.md`, skills and `.claude/` before the next sync, or have agents work in a copy.

`0b drive sync` never brings down an instruction file that no owner or admin wrote or applied (one saved before proposals existed): it reports it as skipped until one of them saves it again. One person's own agent settings, `.claude/settings.local.json` and `CLAUDE.local.md`, stay on their machine and never sync.

What an AI reads from Drive is marked as data unless you saved it: files other apps or mail added, every older version, and all text read out of PDFs, Office files and images come with a header naming who added them and inside a fence, so an AI treats their words as content, not as orders. An `AGENTS.md` or a skill from before this check existed is shown the same way until you save or approve it again.

## Versions

Every save keeps the previous version, and deleting a file keeps its versions, so nothing an AI overwrites is lost. `bridge__drive_versions` lists them and `bridge__drive_restore` brings one back as the newest version (the versions in between stay). In the dashboard, a file's panel has the same. Kept: the newest 20 versions of each file and anything from the last 30 days; older ones are deleted. Old versions don't count toward your space, but they're kept only up to your plan's space: past it, the oldest go first. A deleted file's versions follow the same rules, so it stays restorable until they're gone.

Writes can pass `base_version` (the version the AI read; `0` for a new file): if someone changed the file in the meantime, the write is refused and the AI is told the latest version, instead of overwriting the other change.

## PDFs, Office files and images

Drive reads the text of PDFs and Office files (Word, Excel, OpenDocument and Numbers; not PowerPoint yet) and the text in images, so search finds them and `bridge__drive_read` returns their text, with `<!-- page N -->` marking where each page starts. Images up to 5 MB also come back as the image. Reading takes a few seconds to a minute after an upload; until then a file shows as *extracting…*.

Scanned PDFs (pages that are only pictures) aren't read yet and show as *scanned PDF: no text yet*. If a file looks like it contains a resident registration number, a card or account number, a password or an API key, Drive flags it (⚠ in listings, a heads-up when an AI saves it); it never refuses the file.

Not yet checked on real files: the page markers on real-world PDFs, and how well text in Korean photos is read.

## Tools

| Tool | What it does |
|---|---|
| `bridge__drive_list` | Files under a folder, with sizes, versions, extraction state and flags, and the space used; a folder's instructions, README, skills and address first |
| `bridge__drive_search` | Names and contents, any language (text from PDFs, Office files and images too), with the page and a snippet |
| `bridge__drive_read` | A file's content: text, the text extracted from a document or image (with page markers), or a description; `version`, `offset` and `limit` |
| `bridge__drive_write` | Saves text or base64 bytes at a path, keeping the old version; `base_version`, `note` |
| `bridge__drive_delete` | Removes a file (restorable from its versions); `base_version` |
| `bridge__drive_versions` | A file's versions, newest first |
| `bridge__drive_restore` | Brings back a version as the newest |
| `bridge__skills` | With `folder` (and `workspace`): that folder's skills, one skill's instructions, or one of its files |

Each takes an optional `workspace`: a team workspace's name or id. Without it, it's your own Drive. A token limited to reading sees only the list, search, read and versions tools.

## Space

| Plan | Space |
|---|---|
| Free | 100 MB |
| Plus | 10 GB |
| Team | 20 GB per seat, shared by the workspace |

One file is up to 25 MB. A team workspace whose subscription lapsed keeps its files readable but takes no new ones. [Pricing](/pricing)

## API

```
GET    /api/drive/spaces                       your Drives, with space used
GET    /api/drive?workspace=&prefix=&q=        list or search
GET    /api/drive/content?workspace=&path=     download
PUT    /api/drive/content?workspace=&path=     upload (the body is the file)
DELETE /api/drive/content?workspace=&path=     remove
```

Use a device token (`0b login`) as `Authorization: Bearer …`.

## Privacy

Unlike the vault and the [personal files](/docs/files) that `0b files` syncs, the server can read Drive files: chat apps have to search and read them, and Drive reads the text out of documents and images (with Cloudflare Workers AI) so they can be searched. They're stored encrypted at rest on Cloudflare R2 and are reachable only from your account (and, in a team workspace, its members). Deleting a file keeps its versions (so it can be restored) until they're pruned: after the newest 20 and 30 days, or sooner past your plan's space. The content and the text read out of it go a day after nothing refers to them. Everything goes when you delete your account.
