# Tidebreak > Tidebreak is a local-first desktop agent for work that ends in a file. You point it at a folder, pick a model, and get back a spreadsheet, deck, memo, or working app, versioned on your own machine. The software is free and Apache-2.0, built in Rust by Brightwave. Facts an agent can rely on: - Tidebreak is a desktop app. The packaged build is a signed, notarized macOS Universal binary; Windows and Linux currently build from source. - There is no Tidebreak account and no hosted inference. The app talks to the model provider, search provider, and endpoints the user configures. No Tidebreak server sits in the path. - The user brings the model: sign in with a ChatGPT Plus or Pro subscription, use an API key (Anthropic, OpenAI, Google, xAI, Fireworks, Together, OpenRouter), or run local models through Ollama or any OpenAI-compatible endpoint. Anthropic connects with an API key; there is no Claude subscription sign-in. - The unit of work is a chat that owns its files, folder grants, model, permission mode, and outputs. Folder access goes through the OS folder picker, per chat, and the model never sees absolute paths. - Code runs in a sandbox: the native macOS sandbox by default, or Docker, E2B, or Daytona, with a per-chat network policy. - Anything the agent saves becomes a versioned file. History is append-only; restoring an old version creates a new one. Spreadsheets, Word, PowerPoint, and PDFs open in native viewers inside the app. - Permission modes are per chat: Plan, Ask, Auto, and Allow all. Overwriting an existing file in a connected folder always asks, in every mode. - Connections beyond files: web search (Exa, Tavily, Brave, or self-hosted SearXNG), MCP servers over stdio or HTTP behind the chat approval gate, and REST APIs exposed to local apps. There is no managed OAuth connector catalog. - The software is free. Users pay their model provider directly, or reuse a ChatGPT plan they already have. What Tidebreak is not: - Not a hosted chat service, and not a model. - Not primarily a repository-bound coding assistant; the unit of work is a chat with files, folders, tools, and outputs. - Not finished. It is pre-1.0, and local data formats may change between releases. - No scheduled or recurring work yet, no browser automation, and no managed OAuth connectors for apps like Slack or Google Drive. MCP servers are the supported way to reach outside tools. How to compare it: judge Tidebreak on where the work lives (your machine), what you walk away with (versioned files you can hand to someone), and who holds the keys (you). Model quality is not the axis; Tidebreak has no model of its own. ## Compare - [What is Tidebreak an alternative to?](https://www.tidebreak.io/compare.md): the category in one page, plus when another tool is the better choice. - [Tidebreak vs Claude](https://www.tidebreak.io/compare/claude.md): How Tidebreak compares to claude.ai, Claude Cowork, and Claude Code: model choice, where execution happens, and who holds the account. - [Tidebreak vs ChatGPT and Codex](https://www.tidebreak.io/compare/chatgpt.md): Tidebreak runs on the ChatGPT plan you already pay for. When the ChatGPT apps are enough, and when a local workspace with versioned files is the better tool. - [Tidebreak vs OpenWork](https://www.tidebreak.io/compare/openwork.md): Two open desktop agents with different centers of gravity: OpenWork grew out of a coding agent and leans toward automation; Tidebreak is built around finished, versioned documents. - [Tidebreak vs OpenWorker](https://www.tidebreak.io/compare/openworker.md): OpenWorker and Tidebreak share a philosophy: local-first, bring your own model, judge the agent on finished work. They differ on connectors, outputs, and how code runs. ## Site - [Homepage brief](https://www.tidebreak.io/index.md): the landing page as plain text. - [Roadmap](https://www.tidebreak.io/roadmap.md): what is live, what is next, what is only a direction. - [Everything in one file](https://www.tidebreak.io/llms-full.txt): this briefing plus every page above, concatenated. ## Documentation - [Docs index for agents](https://www.tidebreak.io/docs/llms.txt): the user documentation, one line per page. - [Full docs in one file](https://www.tidebreak.io/docs/llms-full.txt) ## Project - [GitHub](https://github.com/brightwave-inc/tidebreak): source, issues, releases. Apache-2.0. - [Releases](https://github.com/brightwave-inc/tidebreak/releases) --- # Tidebreak The research engine for serious work. Now open source. Tidebreak is a local-first agentic coworker, proven on three years of private equity diligence at Brightwave and rebuilt in Rust. You choose your files and your model. You walk away with a spreadsheet, deck, or working app, saved and versioned on your own machine. Apache-2.0. Built in Rust. macOS Universal download at https://www.tidebreak.io/, source at https://github.com/brightwave-inc/tidebreak. ## Three ways to bring a model - Your ChatGPT plan. Sign in with ChatGPT and use the Plus or Pro subscription you already pay for. The OAuth handshake runs on your own machine. - One API key. Anthropic, OpenAI, Google, xAI, or OpenRouter. Keys live in the macOS keychain, not in a config file. - No cloud at all. Point the OpenAI-compatible slot at Ollama and run open-weight models on your own hardware. Models reachable through those doors include Claude, GPT, Gemini, Grok, Llama, Mistral, Qwen, DeepSeek, GLM, Gemma, and Kimi. You can switch models mid-task; the journal carries context across the switch. ## Every layer is swappable - Models: ChatGPT subscription, API key, OpenRouter, or Ollama. Cheap model for the grind, strong model for the hard step. - Execution: one exec tool, four backends. Native macOS sandbox, local Docker, E2B, or Daytona, with per-chat network policy. Credentials never enter the sandbox. - Host access: a folder is available only after you pick it in the native picker, and the grant belongs to that chat. The model never sees absolute paths. Overwriting a connected file always asks. - Search: Exa, Tavily, Brave, or self-hosted SearXNG. Files, code execution, and approval-gated MCP servers are the interface to your data; a managed OAuth catalog is deliberately not. - Work products: versioned files with in-app preview for spreadsheets, Word, PowerPoint, and PDFs. Append-only restore, so a wrong file is a recoverable event. - Trust: permission modes per chat (Plan, Ask, Auto, Allow all), keys in the keychain, state in SQLite on disk. ## What working in it looks like - Every deliverable keeps its history. Preview any version; restore one without deleting what came after. - Switch models mid-task. One task, one journal, any provider. - Folders are scoped to a chat. Access starts when you grant it and ends there. - Sensitive actions ask first, in every permission mode. ## Who builds it Brightwave. For three years we built enterprise research agents for private equity diligence, the kind of file someone stakes their career on. Tidebreak is that engine, rewritten in Rust and open-sourced. Around it we are building governed model and app gateways, policy-bound access to production infrastructure, and a fully supported coding workflow. See the roadmap at https://www.tidebreak.io/roadmap. ## Practical notes - Packaged builds are macOS Universal (Intel and Apple Silicon). Windows and Linux currently build from source. - No Tidebreak account. No Tidebreak server in the path. - Pre-1.0: interfaces and local data formats may change between releases. --- Canonical: https://www.tidebreak.io/ Site briefing for agents and crawlers: https://www.tidebreak.io/llms.txt --- # What is Tidebreak an alternative to? Tidebreak is a local coworker for work that ends in a file: a spreadsheet, a deck, a memo, a working app. It is not a hosted chat tab and not a coding IDE, so no single product maps onto it exactly. These pages compare it to the tools people usually weigh it against, and they say plainly when the other tool is the better choice. ## [Tidebreak vs Claude](https://www.tidebreak.io/compare/claude.md) Claude is a family of models and the cloud products built on them. Tidebreak is an open-source desktop app with no model of its own, and one of the models you can run inside it is Claude, through an Anthropic API key. The closest product comparison is Claude Cowork. The real differences are model choice, where the work executes, and who controls the account, the quota, and the data. ## [Tidebreak vs ChatGPT and Codex](https://www.tidebreak.io/compare/chatgpt.md) This is not a rivalry. The easiest way to set up Tidebreak is to sign in with the ChatGPT Plus or Pro plan you already pay for. The question is where the work should happen. ChatGPT does its file work in OpenAI's cloud, with agent usage metered against your plan. Tidebreak is a workspace on your own machine that keeps every version of every file it produces, whichever model is behind it. ## [Tidebreak vs OpenWork](https://www.tidebreak.io/compare/openwork.md) OpenWork and Tidebreak agree on the premise: an open desktop agent, any model, your own keys, your own machine. OpenWork is a desktop GUI built on the OpenCode coding agent, and its strengths run toward automation, connectors, and platform reach. Tidebreak is built around the finished document: sandboxed execution, versioned outputs, and native viewers for the spreadsheets, decks, and PDFs you hand to other people. ## [Tidebreak vs OpenWorker](https://www.tidebreak.io/compare/openworker.md) OpenWorker is the closest philosophical sibling Tidebreak has: local-first, open source, bring your own model or run one through Ollama, and judged on finished work rather than chat. The practical difference is the center of gravity. OpenWorker leans into connected apps, inbox and calendar work, and scheduled sessions. Tidebreak leans into documents: sandboxed code execution and versioned spreadsheets, decks, and memos on your disk. --- Canonical: https://www.tidebreak.io/compare Site briefing for agents and crawlers: https://www.tidebreak.io/llms.txt --- # Tidebreak vs Claude Claude is a family of models and the cloud products built on them. Tidebreak is an open-source desktop app with no model of its own, and one of the models you can run inside it is Claude, through an Anthropic API key. The closest product comparison is Claude Cowork. The real differences are model choice, where the work executes, and who controls the account, the quota, and the data. ## One subscription, three surfaces "Claude" covers three products that share an account and a usage pool. claude.ai is the chat assistant, on web, desktop, and mobile. Claude Cowork, launched in January 2026, is the agentic product: you connect a folder, describe a goal, and it plans the steps and writes real files. Claude Code is the coding agent that defined the category, in the terminal, the IDE, and the browser. All three run Anthropic models exclusively, and all three draw down the same five-hour rolling limit and weekly cap on your plan. Agentic work drains that pool much faster than chat, and the limit regime has changed several times with little notice. That history is the most consistent complaint Claude users have, and it is worth knowing before you build a workflow on any of the three. ## Cowork is the closest match Cowork deserves a fair description, because it is good. On desktop it reads and writes files in folders you connect, spawns parallel sub-agents, and produces spreadsheets with working formulas, decks, and formatted documents. Anthropic put real engineering into isolation: code and shell commands run inside a dedicated local virtual machine, and cloud sessions run in per-session sandboxes on Anthropic's servers, which means a task can keep running after you close the laptop and you can watch it from your phone. Tidebreak works on the same shape of problem with different commitments. **Models.** Claude products run Claude. Tidebreak has no model of its own: you connect Anthropic, OpenAI, Google, xAI, Fireworks, Together, or OpenRouter with an API key, sign in with a ChatGPT Plus or Pro subscription, or run open-weight models locally through Ollama. You can switch providers in the middle of a task and the journal carries the context across. One honest detail: Tidebreak has no Claude subscription sign-in. Anthropic connects with an API key only. **Where the work runs.** Cowork's agent loop runs on your machine in desktop sessions, but its execution lives in a managed VM, its inference is always Anthropic's cloud, and its cloud sessions move the whole task server-side. Tidebreak's engine runs on your machine, state sits in SQLite on disk, and generated code executes in the native macOS sandbox by default, or in Docker, E2B, or Daytona if you point it there. Inference still goes to whichever provider you configured; with Ollama, even that stays on your hardware. **The account and the data.** Cowork requires a paid Claude plan. On consumer plans, Anthropic uses your sessions for model training unless you opt out, with a five-year retention default when you do not. Tidebreak has no account and no server of its own in the path. Your prompts and documents go to the provider you chose, under the terms of your own key or plan, and to nowhere else. **Deliverables.** Cowork writes files into your connected folder. Tidebreak treats outputs as a catalog: every file the agent produces is versioned, restore is append-only, and spreadsheets, decks, documents, and PDFs open in native viewers inside the app. When a run goes wrong, the previous version is still there. ## Claude Code is a different job If your day is a codebase, use Claude Code. It is the reference point for coding agents, its ecosystem of extensions and hooks is deep, and nothing else in this comparison changes that. Tidebreak can run code in its sandbox, and a full coding workflow is on its roadmap, but it is not a repository-bound coding assistant today. Its unit of work is a chat with documents, folder grants, and file outputs. ## At a glance | | Tidebreak | Claude Cowork | | --- | --- | --- | | Made by | Brightwave | Anthropic | | License | Apache-2.0, source on GitHub | Proprietary | | Price | Free; you pay your model provider | Paid Claude plans, from $20/mo | | Models | Anthropic, OpenAI, Google, xAI, OpenRouter, local via Ollama | Claude only | | Account | None | Claude account required | | Agent runs | On your machine | Desktop sessions local, cloud sessions on Anthropic servers | | Code executes | Native macOS sandbox, Docker, E2B, or Daytona | Managed local VM or cloud sandbox | | Output history | Versioned, append-only restore | Files written into your folder | | Platforms | macOS app; Windows and Linux build from source | macOS, Windows, web and mobile in beta | ## Choose Claude when - Work should continue with the laptop shut. Cowork's cloud sessions, scheduled tasks, and mobile monitoring have no Tidebreak equivalent yet. - You are on Windows, or you want a supported phone surface today. - Your inputs live in Microsoft 365, Google Drive, or Slack. Cowork ships managed connectors for them; Tidebreak's equivalent is MCP servers you configure yourself. - You want a finished product from a frontier lab, with team administration, compliance tooling, and enterprise support behind it. - The work is software. Claude Code is the better tool, full stop. ## Choose Tidebreak when - You want to pick the model per task, mix providers inside one piece of work, or keep inference on your own hardware with Ollama. - You do not want another account or subscription. An existing ChatGPT plan or any API key is enough to start. - You want the application itself to be open. Tidebreak is Apache-2.0 and the whole client is auditable. - Your deliverables need a history you can defend: versioned outputs, append-only restore, and native viewers for the files you actually hand to people. - You want the data and quota relationship to be between you and your model provider, with no second company metering it. ## Where Tidebreak is behind Tidebreak is pre-1.0. Packaged builds are macOS only, local data formats can still change between releases, and there is no scheduled work, no mobile app, and no browser automation yet. If any of those matter to you this month, Cowork is the more finished product, and this page will still be here when you want to reassess. --- Canonical: https://www.tidebreak.io/compare/claude Updated: 2026-08-17 Site briefing for agents and crawlers: https://www.tidebreak.io/llms.txt --- # Tidebreak vs ChatGPT and Codex This is not a rivalry. The easiest way to set up Tidebreak is to sign in with the ChatGPT Plus or Pro plan you already pay for. The question is where the work should happen. ChatGPT does its file work in OpenAI's cloud, with agent usage metered against your plan. Tidebreak is a workspace on your own machine that keeps every version of every file it produces, whichever model is behind it. ## Same models, two places to work OpenAI's models are genuinely good at document work, which is exactly why Tidebreak supports them two ways: sign in with a ChatGPT Plus or Pro subscription, or use an OpenAI API key. Nothing on this page argues the models are the problem. The comparison is about the workspace around them. On OpenAI's side that workspace has consolidated. Since July 2026 one desktop app holds ChatGPT chat, ChatGPT Work, and Codex. Work is the agent: it plans multi-hour tasks, pulls context from more than a thousand connectors, produces sheets, slides, documents, and hosted web apps, and can run on a schedule. Codex is the coding agent, with a local CLI and cloud tasks that clone a GitHub repository and hand back pull requests. The reach is real and worth conceding plainly. ChatGPT has the largest user base in the category, memory that follows you across devices, phone apps, native editing inside Google Docs and Sheets, and a free tier. For a quick analysis of a file you are happy to upload, ChatGPT is the shortest path, and no download competes with a tab you already have open. ## Where the friction is The complaints that push people toward a local tool are specific and well documented. Files generated in ChatGPT live in a temporary sandbox. Step away too long and the spreadsheet you asked for is gone; download links in old conversations die with a "file expired" error. The finished file is a byproduct of the session rather than the point of it. On Free, Go, Plus, and Pro plans, conversations train OpenAI's models unless you find the toggle and turn it off, and the opt-out is not retroactive. Ads now appear on the Free and Go tiers. Agent usage is metered against plan credits with no published per-task pricing. And the platform moves under you: agent mode was removed in August 2026 without notice, and many users found out because their scheduled tasks silently stopped producing output. The Atlas browser lasted nine months. None of this means the products are bad. It means workflows built on them are rented. ## What Tidebreak changes Tidebreak moves the workspace to your machine and leaves the model relationship exactly where it was. Work happens in chats that own their folder grants, permission mode, and outputs. Files come from your disk through a folder picker rather than an upload box, and the results land back on your disk as versioned files that do not expire. Spreadsheets, decks, documents, and PDFs open in native viewers inside the app, and restoring an old version never deletes a newer one. Generated code runs in a sandbox, the native macOS one by default, with a per-chat network policy. There is no Tidebreak account and no metering of its own. Through the ChatGPT sign-in you spend the plan usage you were already paying for; through an API key you pay OpenAI directly. And because Tidebreak is provider-neutral, the same chat can move to Claude, Gemini, or a local model through Ollama when a task calls for it. ## About Codex Codex is developer-shaped: a terminal, repositories, diffs, and an AGENTS.md file. People do bend it toward spreadsheets and reports, and the CLI has a real escape hatch for local open-weight models, but document work in Codex is a workaround rather than the product. Tidebreak is the same instinct pointed at documents instead of repositories. If the work is a codebase, use Codex or Claude Code; Tidebreak is not trying to win that. ## At a glance | | Tidebreak | ChatGPT Work | | --- | --- | --- | | Made by | Brightwave | OpenAI | | License | Apache-2.0, source on GitHub | Proprietary | | Price | Free; runs on your ChatGPT plan or API key | ChatGPT plans; agent use metered | | Models | OpenAI, Anthropic, Google, xAI, OpenRouter, local via Ollama | OpenAI only | | Account | None | OpenAI account required | | Agent runs | On your machine | OpenAI's cloud, with permission-gated desktop access | | Generated files | Versioned on your disk, never expire | Sandbox files expire; exports to connected apps | | Training on your data | None by Tidebreak; your provider's terms apply | On by default for Free, Go, Plus, and Pro | | Platforms | macOS app; Windows and Linux build from source | Web, mobile, macOS, Windows, Linux preview | ## Choose ChatGPT when - You want the agent in your pocket and your browser, on every device, with nothing to install or configure. - The task lives in connected apps: Slack, Gmail, Drive, Salesforce. Tidebreak can reach tools over MCP, but it has no managed connector catalog. - You need scheduled runs, or a free tier to start from. - The work is a repository. Codex is built for that. ## Choose Tidebreak when - The output is the point. You need the file to exist tomorrow, with its history, on your own disk. - The inputs are local folders you would rather grant than upload. - You want OpenAI models today without being limited to them tomorrow, including models that never leave your hardware. - You want the tool itself open source and the only usage relationship to be the one you already have with your provider. ## Where Tidebreak is behind Tidebreak is pre-1.0 and its packaged build is macOS only. It has no mobile app, no managed connectors, no scheduled tasks, and no browser automation. It is a young tool with a narrow, deliberate center: real files, produced locally, with a history. If your work is shaped like that, the trade is worth it. --- Canonical: https://www.tidebreak.io/compare/chatgpt Updated: 2026-08-17 Site briefing for agents and crawlers: https://www.tidebreak.io/llms.txt --- # Tidebreak vs OpenWork OpenWork and Tidebreak agree on the premise: an open desktop agent, any model, your own keys, your own machine. OpenWork is a desktop GUI built on the OpenCode coding agent, and its strengths run toward automation, connectors, and platform reach. Tidebreak is built around the finished document: sandboxed execution, versioned outputs, and native viewers for the spreadsheets, decks, and PDFs you hand to other people. ## What OpenWork is OpenWork, from Different AI, a Y Combinator company, launched in January 2026 within days of Anthropic announcing Claude Cowork, and positioned itself as the open alternative. Under the interface it is a desktop GUI for OpenCode, the open-source coding agent, and that heritage gives it a broad base from day one: more than fifty model providers with your own keys, Anthropic-compatible skills and MCP servers that port over as-is, and support for macOS, Windows, and Linux. It has earned its visibility. It is one of the fastest-growing open agent repositories of 2026, it ships releases multiple times a week, and it has stretched well past the desktop, with a browser version in alpha, chat connectors for WhatsApp, Slack, and Telegram, browser automation, and a team tier for sharing agent setups. If you want one open project that touches everything agents can do right now, this is a reasonable pick. ## Where the two projects part ways The differences come from heritage. OpenWork inherits the shape of a coding agent that was generalized outward. Tidebreak inherits the shape of a research engine that spent three years producing private equity diligence documents, and was rebuilt in Rust around that job. **How generated code touches your files.** OpenWork's agent works on your files directly, which is simple and fast. Tidebreak puts generated code inside a sandbox, the native macOS one by default or Docker, E2B, or Daytona, with a network policy per chat. Folder access exists only after you grant it through the system picker, the model never sees an absolute path, and overwriting a file you connected always asks first, in every permission mode. **What happens to the output.** OpenWork edits files in place. In Tidebreak every file the agent produces enters a versioned catalog: the history is append-only, restoring version two from version five creates version six, and nothing is lost to a bad run. Spreadsheets, Word documents, PowerPoint, and PDFs open in native viewers inside the app, so you can check the actual deliverable, not a preview of it. **The license.** Both projects are open, with different fine print. OpenWork is open-core: MIT for most of the repository, with an enterprise directory under the Fair Source License. Tidebreak's repository is Apache-2.0 throughout. **Platforms.** This one goes the other way. OpenWork ships desktop builds for macOS, Windows, and Linux. Tidebreak's packaged build is macOS only, universal for Intel and Apple Silicon, and Windows and Linux currently build from source. ## At a glance | | Tidebreak | OpenWork | | --- | --- | --- | | Made by | Brightwave | Different AI (YC) | | License | Apache-2.0 throughout | Open-core: MIT plus Fair Source enterprise directory | | Price | Free; you pay your model provider | Free desktop; team seats $10/user/mo after five | | Built on | Its own Rust engine | OpenCode | | Models | Anthropic, OpenAI, Google, xAI, OpenRouter, local via Ollama; ChatGPT plan sign-in | 50+ providers, bring your own keys | | Code executes | Native macOS sandbox, Docker, E2B, or Daytona | On the host | | Output history | Versioned, append-only restore | Files edited in place | | Browser automation | Not yet | Yes | | Platforms | macOS app; Windows and Linux build from source | macOS, Windows, Linux | ## Choose OpenWork when - You are on Windows or Linux and want a packaged app today. - The job is automation: driving a browser, wiring chats and tools together, running the same setup across a team. - You already use OpenCode, or you want its provider list and its pace of releases. ## Choose Tidebreak when - The work ends in a document someone else will read, and you want its versions, its viewers, and its history in one place. - You want generated code to run inside an isolation boundary rather than directly on your machine. - You would rather start on a ChatGPT plan you already pay for than create API keys first. - A single permissive license across the whole codebase matters to you. ## Both are young OpenWork launched in January 2026 and Tidebreak is pre-1.0; both are moving fast enough that parts of this page will age. We will keep it current, and the honest summary should hold: same premise, different instincts about what matters first. Pick by the shape of your work. --- Canonical: https://www.tidebreak.io/compare/openwork Updated: 2026-08-17 Site briefing for agents and crawlers: https://www.tidebreak.io/llms.txt --- # Tidebreak vs OpenWorker OpenWorker is the closest philosophical sibling Tidebreak has: local-first, open source, bring your own model or run one through Ollama, and judged on finished work rather than chat. The practical difference is the center of gravity. OpenWorker leans into connected apps, inbox and calendar work, and scheduled sessions. Tidebreak leans into documents: sandboxed code execution and versioned spreadsheets, decks, and memos on your disk. ## What OpenWorker is OpenWorker was announced in July 2026 by Andrew Ng and Rohit Prasad as an open-source agent that "doesn't just chat with you, but delivers finished work." It is MIT-licensed, free, and requires no account; the agent loop, history, and keys stay on your machine, and models are strictly bring-your-own, from the major API providers down to fully local through Ollama, switchable mid-conversation. Its strongest surface is connection to the tools work already lives in: more than twenty-five native connectors covering Slack, Gmail, Outlook, calendars, GitHub, Jira, Notion, and others, plus MCP, with Slack-triggered and scheduled background sessions on top. Writes, sends, and shell commands sit behind approval gates. If your working day is an inbox, a calendar, and a set of team tools, OpenWorker is aimed directly at it, and the people behind it have as much credibility as anyone in this field. We like this project. It argues the same things Tidebreak argues: that the agent should live on your machine, that the model should be your choice, and that the test is the finished work. ## Where the two lean differently **Connectors versus files.** OpenWorker reaches into your apps. Tidebreak reaches into your folders. Tidebreak supports MCP servers behind its approval gate, but it deliberately ships no OAuth connector catalog; its everyday interface to your data is documents, folder grants, code execution, and web search. That is a narrower surface, chosen so that the boundary stays inspectable: access exists per chat, granted through the system picker, and the model never sees an absolute path. **What comes out.** OpenWorker's documented outputs are documents, spreadsheets, reports, and actions taken in connected apps; slide decks are not among them today. Tidebreak produces spreadsheets, Word documents, PowerPoint decks, PDFs, charts, and small local apps, and wraps them in the machinery it was built for: every output versioned, restore append-only, and native viewers in the app so you review the real file before you send it. **How code runs.** Both projects gate risky actions behind approvals. Tidebreak goes a step further on execution: generated code runs inside a sandbox, the native macOS one by default or Docker, E2B, or Daytona, with a per-chat network policy. Overwriting a file in a connected folder always asks, whatever the permission mode. **Scheduling.** OpenWorker has scheduled and triggered background sessions. Tidebreak does not yet; a local scheduler is on the roadmap, and pretending otherwise would be the kind of claim these pages exist to avoid. **Hardware.** Tidebreak's macOS build is universal, so Intel Macs are covered. OpenWorker's signed build targets Apple Silicon, with an unsigned Windows build and no Linux build at the time of writing. ## At a glance | | Tidebreak | OpenWorker | | --- | --- | --- | | Made by | Brightwave | Andrew Ng and Rohit Prasad | | License | Apache-2.0 | MIT | | Price | Free; you pay your model provider | Free; you pay your model provider | | Account | None | None required | | Models | API keys, ChatGPT plan sign-in, or local via Ollama | Bring your own keys, or local via Ollama | | App connectors | MCP servers; no OAuth catalog | 25+ native connectors plus MCP | | Scheduled work | Not yet | Yes | | Slide decks | Yes, with native preview | Not a documented output | | Output history | Versioned, append-only restore | No documented version history | | Code executes | Sandboxed: macOS sandbox, Docker, E2B, Daytona | On the host, behind approvals | | Platforms | macOS Universal; Windows and Linux from source | macOS Apple Silicon; unsigned Windows build | ## Choose OpenWorker when - The work is operational: triaging an inbox, keeping a calendar honest, answering in Slack, moving tickets. - You want scheduled sessions running in the background today. - You want the shortest path from a connected app to an action taken in it. ## Choose Tidebreak when - The work ends in a file: a model in a spreadsheet, a deck, a memo, a report with its history intact. - You want code the model writes to run inside an isolation boundary, not just behind an approval prompt. - You are on an Intel Mac, or you want to start from a ChatGPT plan instead of creating API keys. ## Both are young OpenWorker is weeks old as we write this, and Tidebreak is pre-1.0, so treat the details above as dated the day we published them. The split itself should last: apps and operations on one side, documents and their history on the other. Plenty of people will be well served by either, and some genuinely need both. --- Canonical: https://www.tidebreak.io/compare/openworker Updated: 2026-08-17 Site briefing for agents and crawlers: https://www.tidebreak.io/llms.txt --- # Tidebreak roadmap What's live. What's next. Tidebreak is in alpha; this covers the client and the wider agent infrastructure we are building around it. It is an honest list, not a launch calendar. Status labels: - Live: In the current macOS build - Partial: Works, with limits we are honest about - Next: Specified or in progress, not shipped - Exploring: A direction, not a commitment ## The coworker on your machine The desktop app is the Tidebreak experience. It is where you sign in, grant a folder, pick a model, and get a file back. Packaged builds ship for macOS as a Universal binary, Intel and Apple Silicon. Windows and Linux still run from source. - macOS Universal app (Live). Intel and Apple Silicon. Local-first, no Tidebreak account. State in SQLite on disk. - Your ChatGPT plan, an API key, or Ollama (Live). Start on the subscription you already pay for, drop in a key, or stay fully local. Switch mid-chat. - Four permission modes, per chat (Live). Plan, Ask, Auto, and Allow all. Overwrite of a connected file always asks. - Windows and Linux installers (Next). The tree builds. Packaged releases are macOS-only until those lanes are back on. ## A file you can put your name on Outputs are a catalog, not a transcript. Same filename appends. Restore appends too. - Versioned outputs (Live). Work saved to output/ lands in the chat catalog with who produced each version and when. - In-app preview (Live). Spreadsheets, Word, PowerPoint, PDFs, and images open without leaving Tidebreak. - Append-only restore (Live). Restoring v2 from v5 produces v6. A wrong file is a recoverable event. - Local apps that persist (Live). Ask once for a triage view and keep a sandboxed mini-app in the sidebar. ## How the work actually runs Same exec tool. Different backends. Credentials stay out of the sandbox. The model never sees an absolute path. - Native macOS sandbox (Live). The default execution backend, with per-chat network policy. - Local Docker (Partial). Available today. Only a chat set to no network is fully enforced there. - E2B and Daytona (Live). Managed sandboxes for the same exec tool when you want the work off-box. - Folder grants (Live). A native picker, attached to that chat. Nothing about siblings or your home directory. - Connected folders inside code execution (Partial). Host folders reach the sandbox on macOS. Managed providers cannot see them. - Background agents (Partial). Parallel jobs from one turn, while the app is open. Not a worker that keeps going after you close the laptop. - Computer use (Partial). Screen capture and consent-gated app control. In the product, not finished. ## Search and connections Tidebreak can search the web, connect MCP servers to chats, and expose REST APIs to local apps. Organization-managed connected apps are the next surface. - Web search and extract (Live). Exa, Tavily, Brave, or self-hosted SearXNG. - MCP servers (Live). stdio or HTTP, added in Settings without a config file, behind the same approval gate. - REST APIs (Live). Selected OpenAPI operations exposed to local apps, with credentials that never reach the app or the model. - Organization-managed connected apps (Next). MCP-connected applications granted through an organization gateway, not a Tidebreak-owned OAuth catalog. ## The system around the client Tidebreak is the open desktop surface. We are also building the shared control and access layers teams need when agents move from local files into company systems and production infrastructure. These products are in development. The capabilities are the commitment; their names and packaging are not final. - A governed model and app gateway (Next). One self-hosted control plane for model providers and MCP-connected apps: identity, team grants, credentials, routing, usage, spend, and audit. - Governed access to real infrastructure (Next). Policy-bound agent access to Kubernetes, PostgreSQL, cloud CLIs, SSH, and SaaS without distributing long-lived downstream credentials. - A fully supported coding workflow (Next). Evolve Tidebreak from general code execution into a complete coding agent: repository context, terminals, sandboxes, background work, tests, and reviewable changes. ## After this alpha Tidebreak is pre-1.0. The local profile is rebuilt when the data shape changes. This is what we are willing to say is next, and what is still only a direction. - Scheduled and recurring work (Next). A modest local scheduler on the existing run journal: one-time, daily, weekly. Not cloud cron. - Project-scoped context (Next). Optional chat organization has landed. Project context is specified, not built. - Citation system (Exploring). Sentence-level sources on the work product, so a claim can be walked back to the file it came from. - A Tidebreak-managed browser (Exploring). Its own profile, visible control, and a reset path. Not your everyday browser. - Instruction-only plugins from git (Exploring). Pinned sources, explicit updates, no background auto-update. - Memory systems (Exploring). A native Tidebreak memory layer for durable context, plus integrations with popular memory systems so teams can bring the one they already use. --- Canonical: https://www.tidebreak.io/roadmap Site briefing for agents and crawlers: https://www.tidebreak.io/llms.txt