OpenSail

OpenSail

OpenSail is the open-source alternative to Codex App, Claude Desktop, Cursor, and Cowork for agentic software work.

Docs · Quickstart · Join Discord · Releases

Build AI apps, agents, workflows, and automations you can inspect, run, share, and own. Turn recurring work from Slack, email, spreadsheets, tickets, approvals, and internal tools into runnable software. Manage your fleet of agents. Connect real systems. Add approvals, budgets, permissions, logs, schedules, and human review. Run it on your infrastructure. Use any model. Open source. Your cloud, your code, your control.

---

OpenSail is an open platform for building, running, and sharing AI workflows, apps, agents, and automations you can inspect and own.

It is for anyone with a process that keeps coming back: a founder chasing follow-ups, an operator buried in handoffs, a lawyer managing intake and documents, a support team routing issues, a developer building internal tools, or a company giving people a sanctioned place to build useful AI.

Start with a workflow in plain English: "every morning, check these sources, summarize what changed, update Linear, and send the result to Slack." OpenSail turns that into a real runnable system with a trigger, an agent or app action, selected tools and connectors, delivery targets, approval gates, budget limits, run history, and a sandboxed workspace when the workflow needs files, code, or services.

For builders, OpenSail is a way to turn useful AI experiments into durable software. For leaders, it is a control plane for letting teams move fast while keeping data, infrastructure, cost, permissions, and auditability under control.

Under the hood, OpenSail runs on portable, snapshot-backed workspaces. Agents and apps can sleep when idle, wake when needed, keep state across runs, and move from your local desktop to your own cloud with the same project state intact.

---

What OpenSail Helps You Run

OpenSail workflows can be scheduled, triggered, connected, approved, budgeted, tracked, packaged, and reused. The goal is durable AI software your team can trust.

Start small:

• Run a task on a schedule, from a button, from a webhook, from Slack or email, or when an app event happens
• Assign the work to an agent, an installed app action, or a lightweight connector-only automation
• Use built-in builder agents to create agents, wire connectors, and attach schedules from chat
• Give the agent only the skills, tools, connectors, and apps it needs for that job
• Connect business systems like Slack, Linear, GitHub, Salesforce, Gmail, internal APIs, and MCP servers
• Send the result to Slack, email, a webhook, the OpenSail inbox, or another app

Add control when the work gets serious:

• Require approval before risky actions happen, then approve from Slack, email, or the web app
• Pause and resume runs at approval boundaries while the system keeps processing other work
• Set per-run and daily budgets so AI and compute spend stays bounded
• See what ran, what it cost, what systems it touched, what it produced, and who approved it
• Keep credentials safe behind the Connector Proxy so apps use tools through scoped runtime calls
• Let lightweight jobs stay cheap, and give heavier jobs a real workspace when they need files, code, terminals, databases, or running services

Package what works:

• Publish a workspace project as an installable app
• Expose typed actions, views, and data resources that other apps, agents, and dashboards can reuse
• Install an app and run one of its actions inside an automation
• Let an agent call an app when the job needs structured, reliable work
• Fork useful apps, share them with a team, or turn them into reusable building blocks

Examples:

• Software Request Reviewer - checks new tool requests against policy, budget, security requirements, and approved vendors, then files the next step
• Product Feedback Router - watches support, Slack, GitHub, and customer calls, groups recurring pain, and turns it into tickets and weekly summaries
• Weekly Metrics Reporter - pulls data every Friday, creates charts, writes the story, and sends it to the right people
• Lead Follow-up Agent - researches inbound leads, scores fit, drafts replies, updates the CRM, and asks before sending anything sensitive
• Client Intake Assistant - collects forms, checks missing documents, drafts kickoff notes, and keeps status visible
• Billing Review Workflow - compares activity, matter context, invoices, and payment status so teams catch leakage before it becomes a write-off
• Third-Party Risk Manager - researches vendors, checks policy and reputational risk, produces a structured report, and keeps the approval trail
• Multi-container Internal App - ships a real frontend, backend, database, agent, and dashboard as one installable app

OpenSail is for developers, operators, founders, legal teams, support teams, and anyone who can describe the work, knows what "good" looks like, and needs a safe way to make AI do it again tomorrow.

---

Turn best practices into shared agents

Turn institutional knowledge into agents the whole team can run.

Knowledge is scattered across people and systems. OpenSail gives teams a way to turn that knowledge into a reusable agent or workflow that follows the right process, uses the right tools, and can be shared across the organization.

Build once, improve through use, then share or duplicate for new workflows. Because agents have memory and can be guided and corrected in conversation, they get better as teams use them.

Discover what your team has built. Browse shared agents, apps, and workflows. Fork what works. Build on top of what already exists.

Collaborate across tools. Set agents to run on a schedule, or deploy them in Slack so they pick up requests as they come in. Agents join the conversations where work already happens.

Scale a working process. Something that works for one person should work for a hundred. OpenSail handles the infrastructure so you can focus on the workflow.

---

Agents

Give recurring work a capable owner, then manage your fleet as it grows.

OpenSail agents are built for the messy jobs that move through files, apps, people, approvals, and business systems. Describe the outcome, attach the tools it needs, set the rules for when it should ask, and let it work from a real sandboxed workspace with source, state, terminals, connectors, schedules, and run history.

An agent can research a lead, prepare a client intake packet, route product feedback, update a CRM, review a vendor request, build an internal tool, fix a bug, generate a report, or call an installed app when the job needs a structured function. It can start from chat, Slack, email, webhook, schedule, app event, or API call, then send results back where people already work.

Built for finished work. Agents operate inside real workspaces with files, terminals, containers, previews, Git, artifacts, and deploy targets. They can inspect context, make changes, run commands, call tools, invoke app functions, and leave behind a reviewable trail.

Made for background workflows. Schedule agents for daily reports, weekly reviews, customer follow-ups, support triage, billing checks, or monitoring tasks. Each run has a trigger, status, outputs, cost, touched systems, and approval history.

Context that travels. Agents carry the right instructions, skills, connectors, MCP servers, model settings, budget, and tool permissions into each run. The work lives with the workspace, so a useful agent can be forked, improved, shared, and reused.

Manage your fleet of agents. Put frontend, backend, test, ops, research, and review agents in the same workspace. Assign each one a job, give it the right tools, and let the architecture panel show how the software, agents, containers, secrets, and deploy targets connect.

Human control at the right moments. Scope what agents can touch, require approval for sensitive steps, cap spend per run or per day, and inspect the full record after the work completes.

Agents are how OpenSail turns personal process knowledge into durable software. The person closest to the work can describe what should happen, and the platform turns that into something that runs, improves, and scales.

---

Apps

One workspace in. One installable app out.

An app on OpenSail is a versioned, manifest-described bundle. Build it in a workspace, publish it, and anyone can install it with one click. Each install creates a new isolated project with its own volume, containers, runtime contract, permissions, and billing policy.

The lifecycle: build in a workspace, publish a content-addressed version, pass the approval pipeline, list on the marketplace or keep it private/team-only, install per-user, run, update, fork.

Functions: Apps expose typed actions: JSON-schema-validated functions that agents, automations, dashboards, or other apps can call. An action can call an HTTP handler, run a Kubernetes Job, or invoke a hosted agent. Inputs and outputs are validated, artifacts can be persisted, result templates can format the response, and spend is recorded per invocation.

Views: Apps expose embeddable views for cards, drawers, and full pages. Dashboards can compose views from other installed apps through signed embed tokens and scoped grants.

Data resources: Apps expose cached, typed reads backed by actions. A dashboard can ask another app for "current pipeline status" or "last billing review result" and reuse the cached data across runs.

Dependencies: Apps can call other apps through positive grants. Parent apps can invoke child app actions, embed child views, and query child data resources while spend rolls up to the parent run.

Connectors: Apps declare the external systems they need: Slack, GitHub, Gmail, Linear, Salesforce, internal APIs, MCP servers, OAuth, API keys, and webhooks. Proxy-mode connectors let app code call approved services while OpenSail handles secrets, scopes, rotation, and consent.

Automation templates: Apps can ship recommended schedules, manual buttons, and webhook triggers. When a user installs the app, selected templates become user-owned automations they can pause, edit, approve, budget, and monitor.

Billing: The creator decides who pays. Each billing dimension (AI compute, general compute, platform fee) can be set independently to creator-pays, installer-pays, platform-subsidized, or BYOK (bring your own key, routed directly to your provider). Promotional budgets let creators sponsor the first N users, then flip to installer-pays when the fund runs out. Caps and overage behavior are per-dimension.

Approval pipeline: Every published version goes through staged review before it reaches the public marketplace. Automated scans review OAuth scopes, source patterns, dependency posture, and credential handling. Sandbox evaluations run the app against synthetic inputs to measure reliability, cost behavior, and prompt-injection resilience. Human reviewers handle the final sign-off. Private and team installs use a faster internal path, so your first apps ship quickly.

Forking: If the creator allows it, anyone can fork an app. Fork creates a new workspace with full source access and a forked_from provenance link. The marketplace shows fork trees. A lawyer takes a starter "intake" app, forks it to "intake-estate-planning," and republishes for their firm.

Bundles: Group multiple apps into a starter pack. "Install Lawyer Starter" installs 10 apps with consolidated OAuth consent (one Gmail authorization covers all of them), sane defaults, and a dashboard app at the center that embeds the others via signed iframes.

---

Automation Runtime

Triggers, agents, apps, delivery, approvals, and spend in one runtime.

OpenSail's Automation Runtime is the durable execution layer for work that keeps happening. It turns a schedule, webhook, manual run, app event, or channel message into an event, creates a run, executes actions, records artifacts and spend, and delivers the result.

The mental model is Trigger -> Event -> Run -> Action -> Delivery: agent.run sends work to a selected agent, app.invoke calls an installed app function, and gateway.send delivers the output.

Triggers: Start workflows from cron schedules, manual buttons, webhooks, app events, Slack, email, or other connected channels.

Actions: Run an agent, invoke an installed app function, or send a result through the gateway. Lightweight runs stay in Tier 0. Work that needs files, shell commands, services, or previews can wake a sandboxed workspace.

Contracts: Each automation carries an execution contract: allowed tools, allowed MCP servers, allowed apps, compute tier, approval rules, and spend caps. Risky steps pause at approval boundaries and resume from checkpoints after a human decision.

Delivery: Send outputs to Slack, email, webhook endpoints, the OpenSail inbox, or another app. Results can include approval cards, reports, structured JSON, files, screenshots, and delivery receipts.

Observability: Every run keeps its trigger, status, checkpoint, artifacts, spend, touched systems, and approval trail visible to the user who owns it.

---

Build Automations and Agents Autonomously

Describe the system you want, and let OpenSail draft the agent, automation, connectors, schedule, permissions, and review flow.

OpenSail includes built-in agents that help people turn intent into reusable team assets.

Agent Builder: Mention @agent-builder, describe the agent you want, and it drafts a user-owned agent with a name, instructions, model preference, connected MCP servers, skills, and tool permissions. It uses the user's installed resources, produces a review card, and publishes after approval.

Automation Builder: Mention @automation-builder, choose one of your existing agents, describe the schedule and output target, and it drafts a user-owned automation. It attaches the cron trigger, prompt template, delivery targets, compute tier, and spend cap, then waits for the publish-and-activate review.

Service Integrator: Use the Service Integrator agent to connect services, configure MCPs and channels, and make sure agents have the tools they need before a workflow goes live.

These builders make the marketplace practical for everyday teams: build an agent, attach the right systems, schedule it, review it, and share it from the same chat surface.

---

Workspaces

Fork a running environment in seconds.

Every agent, app, and workflow runs inside a workspace. One workspace = one app. Multiple agents can collaborate inside the same workspace (frontend agent, backend agent, test agent working on the same codebase), but the workspace publishes as a single unit.

Workspaces are built on BtrFS, a snapshot-based filesystem that makes everything fast, portable, and persistent.

Instant snapshots. Fork a workspace in seconds. Roll back to any point in time. Branch off a working agent to try something new while the current version keeps serving users. Up to 5 snapshots retained per project for a built-in timeline.

Desktop to cloud. Connect your local OpenSail instance to your own cloud infrastructure. Build locally, push to the cloud, run at scale. Same workspace, same state, smooth handoff.

Share anything. Workspaces are self-contained. Share an agent with your team and they get the full environment: code, state, config, dependencies, and runtime settings.

Stay in control. You decide what tools and data an agent can use, what actions it can take, and when it needs approval. For sensitive steps, require the agent to ask before moving forward. Analytics show you how agents are being used, how many runs they've completed, and who's using them.

---

Agentic coding

Code, ship, an

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: TesslateAI
• Source: TesslateAI/OpenSail
• License: Apache-2.0
• Homepage: https://tesslate.com

Install and usage instructions live in the source repository linked above.