Data and storage

The data folder

The folder is ~/Library/Application Support/OpenOrc on macOS, %APPDATA%\OpenOrc on Windows, and ~/.config/OpenOrc on Linux. The OPENORC_USER_DATA environment variable picks another folder. Settings, then Data, shows the path in use.

Electron keeps the app window's own browser data in the same folder, including the window storage below.

Outside the data folder

• Your repositories. Worktree branches, and refs under refs/openorc/ that keep each turn's checkpoint, task snapshots, and edits a cloud thread's sync set aside. See Git and worktrees.
• Your project's files, only when you ask: exporting a plan, adding a memory to CLAUDE.md or AGENTS.md, saving a file in the Files or Instructions tab, or a Git action such as committing, restoring a checkpoint, moving a thread, or applying a task to your checkout. The Instructions tab can also save your personal instruction file, such as ~/.claude/CLAUDE.md.
• Claude accounts. Moving a thread to another Claude account copies its Claude Code session into that account's folder, so the conversation can continue there.
• The agents' sessions from the cloud. After each cloud turn, and when a thread comes back from the cloud brain, the agent's session is copied into the agent's own folder on your computer, such as ~/.claude/projects.
• Claude's plans folder. A Claude Code thread in Plan mode creates ~/.claude/plans, or plans inside CLAUDE_CONFIG_DIR, if it doesn't exist.
• Temporary folders. Private folders in your system's temporary folder: one per Claude Code process for the files that hold OpenOrc's tool address, scratch space when Codex writes a title or summary in the background, and throwaway Git index files. Each is deleted when its job ends.
• Downloaded updates. The update library keeps a downloaded app update in your system's cache folder.
• The agents' own records. Each CLI keeps its own transcripts, such as ~/.claude/projects and ~/.codex/sessions. OpenOrc never redacts or deletes them, and the provider may keep data on its servers under its own terms.

The database

The database is SQLite, opened by OpenOrc's core process and nothing else. It runs in write-ahead mode with synchronous = NORMAL: a committed write survives an app crash, but the last moments before an operating system crash or power loss can be lost. The schema is a list of migrations, and PRAGMA user_version records how many have run. A migration that fails rolls back and stops startup.

threads.parent_thread_id links a thread to the thread it sits under: the thread whose agent started it with thread_start, the thread you started a subthread from, or, for a subagent, the thread whose agent ran it. audit_events records about 70 kinds of action and who took it (you, an agent, or OpenOrc): starting runs, creating tasks, committing, pushing, restoring files, approval decisions, and more.

Source: packages/db/src/database.ts, schema.ts, repos.ts

Agent events

Everything an agent does arrives as events: text, tool calls, command output, file changes, and approvals. The events table keeps them in order, one row each.

• Events are written in batches, every 50 ms or as soon as 500 are waiting. An event still waiting when the process crashes is lost.
• An event over 8 KiB goes to artifacts, and its row keeps a short preview.
• Images in tool results are written to tool-images/, and the event keeps a link.
• A streamed reply arrives as many small pieces. Once the finished message is stored, the pieces in between are deleted.
• The agents' native output isn't stored here. It goes to logs/provider/.

Message search uses messages_fts, which indexes the redacted text of your messages and the agents' replies, not tool output or reasoning. Every word you type must match the start of a word, up to 8 words, and the command palette shows the best 20 matches.

Source: packages/db/src/ledger.ts, fragments.ts, search.ts

Redaction

Before OpenOrc stores an agent's events, run results, the audit log, the provider log, memories, and Slack requests, it replaces text that looks like a secret with a marker such as [redacted:github-token]. It looks for:

• Known token shapes: GitHub, GitLab, Slack, Anthropic, OpenAI, Stripe, npm, and Hugging Face tokens, Google API keys, AWS access key IDs, OpenOrc device keys, JSON Web Tokens, and private keys, even one cut off before its end line.
• Credentials in context: the token after Bearer or Basic, the password in a URL such as postgres://user:password@host, and a value of 8 or more characters given to a secret name, as in DB_PASSWORD=….
• Secret fields: in structured data, such as a tool's input, the whole value of a field with a secret name, or one named cookie or set-cookie.

A secret name ends in api key, secret, secret key, client secret, access token, auth token, refresh token, private key, password, passwd, or authorization, in any case and with any prefix. Code that only names a secret, such as apiKey: process.env.API_KEY, is left alone.

Some text is stored as written:

• Text an agent reads later, such as plans, task comments, review comments and messages you queue, which stay stored after they are sent. Redacting it would change what the agent gets.
• Text you write and edit: drafts, task descriptions, schedule prompts, pull request review drafts, and Orcling instructions.
• Everything outside OpenOrc's records, such as your project, its Git history, and the agents' own transcripts.

Source: packages/db/src/redact.ts

Settings and secrets

App settings are one JSON row in the settings table. The same table holds memory and text generation settings, the reviewer app's details, the Workspace entrypoint, records of Slack requests (redacted), the last usage reports, upkeep markers, and small records that keep an action from running twice. Each project's settings are stored on its row. Settings lists where each choice lives.

Secrets never go in the database. OpenOrc encrypts them with your system's protected storage (the macOS Keychain, Windows DPAPI, or the Secret Service or KWallet on Linux) and writes each to its own file:

• Each file is written to a temporary file that only you can read, synced to disk, then moved into place.
• The window can save a secret but never read one back. The one exception is a new Slack device key, shown once so you can pass it on; the relay keeps only a hash of it.
• On Linux, OpenOrc refuses to save a secret when the system would store it as plain text.
• On macOS and Linux, development and installed builds use different keychain entries, so one can't read the other's secrets.

Each CLI keeps its own credentials, including Claude Code in the folder of each account you added. OpenOrc doesn't store them. The only agent credentials OpenOrc keeps are in the cloud files above. They hold the tokens and sign-ins made for the cloud, and the Codex or OpenCode keys you approved copying.

Source: packages/core/src/services/settings.ts, apps/desktop/src/main/protected-secrets.ts, apps/desktop/src/shared/protected-secrets.ts

In the cloud

Cloud threads and the cloud brain keep work on the Vercel team or Agent37 account you connect. Your computer still holds each conversation, unless the cloud brain owns it.

• A cloud thread's sandbox holds the thread's checkout with its uncommitted changes, what the project's setup script installed, the agent's installation, and the agent's sessions. Unless the firewall keeps it outside, the agent's sign-in is there too, as a file or in the agent's environment. The files stay while the sandbox sleeps, until you remove the sandbox or delete the thread.
• The cloud brain holds what OpenOrc holds on a computer for its own threads: its database, the copies of the projects you switched on, the worktrees of its threads, and memory for those projects. Its secrets, such as the cloud tokens, its Codex login, and your GitHub sign-in if you switched it on, are in files sealed with AES-256-GCM under the brain's key.
• The brain's key stays in cloud-brain.enc on your computer, and the brain gets it each time it starts, never on its disk. An Agent37 instance keeps it in its environment, so the brain can start again after a restart. On Vercel, the brain's door keeps the key and your Vercel token in a sensitive environment variable of its own project, openorc-door, so it can wake the brain for a phone.

Removing the cloud brain deletes its machine, its disk, the sandboxes it made, and the conversations on it. See Remove cloud resources.

Source: packages/core/src/services/cloud-workspaces.ts, packages/cloud/src/brain/sealed-file.ts, brain/wire.ts, apps/brain/src/secrets.ts, host.ts

Window storage

• Local storage holds drafts and pending requests (openorc.draft.*), such as composer text, task descriptions and comments, and edits in the Instructions tab. It also holds the layout and Preview addresses (openorc.layout), the side panel's tabs (openorc.panel-sessions), appearance (openorc.theme, openorc.palette, openorc.colors, openorc.font, openorc.code-font, and two window transparency keys), setup progress (openorc.onboarding), and a few small choices: the project for a new thread, word wrap, how you last reviewed a pull request, and which notifications were already shown. A thread's draft is also saved in the database.
• IndexedDB holds images pasted into task descriptions (openorc-image-drafts) and unsaved edits to files in the Files tab (openorc-file-drafts).
• The Preview browser has its own persistent session, shared by every Preview. It keeps the cookies and site data of pages you open there, including sign-ins, across restarts. The cookies are encrypted on disk, but on Linux without the Secret Service or KWallet they are only obscured; see Security model.

How long things stay

Almost nothing expires. Threads, events, runs, and memories stay until you delete them, and the database has no size limit. Attachments and audit log entries are never deleted. A thread with no work since before yesterday shows under Resolved, but nothing about it is stored or removed.

The upkeep pass runs 60 seconds after launch and every 6 hours after that. It also returns free space in the database to your disk. A database made by an older version, which can't return free space bit by bit, is rebuilt once at startup if at least 64 MiB and a quarter of the file are free space, the disk has room for the rebuild, and no rebuild failed in the last 3 days. The window then says Tidying up saved history. This happens once and can take a minute.

Source: packages/core/src/services/ledger-upkeep.ts, provider-log.ts, packages/db/src/maintenance.ts

What deleting removes

A thread

Choose Delete thread in a thread's menu, then confirm. OpenOrc closes the thread's agent and removes:

• Its runs, events, run summaries, message log, plans, checkpoints, queued messages, and review comments, plus the refs that kept its checkpoints in Git.
• The threads of its subagents.
• Its worktree, unless another thread still uses it, as forks and threads it started do. Uncommitted changes are committed to the worktree's branch first, and the branch stays. A pull request copy's changes are discarded instead.
• A cloud thread's sandbox, on Vercel or Agent37.

These stay: tasks the thread created, threads it started, its attachments and memories, audit log entries, its lines in the provider log until they expire, and the agents' own session files.

An Orcling's own conversation goes only with the Orcling. A subagent's thread can be deleted once it has finished, and takes the subagents under it along. Its parent thread stays.

A task

Delete task is at the bottom of a task's page. It removes the task, its discussion, its own runs, and its own worktree unless a thread uses it. Uncommitted changes in that worktree are committed to its branch first, and the branch stays. The thread that worked on the task keeps its messages and changes.

A project

On the New thread page, click the project's name, right-click the project in the list, and choose Remove project…. This takes it off the Projects list and deletes nothing: files, worktrees, and history stay, and running work and schedules continue. Add the folder again to bring it back.

An Orcling

Delete followed by the Orcling's name removes its conversation, instructions, and memories. Its folder goes only if it is empty. Threads it worked in keep their history.

Source: packages/core/src/services/threads.ts (delete), workspace.ts, orclings.ts, projects.ts, packages/core/src/handlers/thread-workspace.ts, task-delete.ts

Next steps