Roma vs win.sh: Task Handoffs or Goal-Driven Work?

6 min read Comparisons

Compare Roma’s shared lists with win.sh’s company operator on goals, approval boundaries, recurring work and execution.

Roma and win.sh suit different starting points for delegation: an item someone needs to finish, or a business metric that should guide the next project. For a founder working with a small team, the decision is whether the system should hold shared assignments or also decide which work an outcome needs.

Roma documents shared lists with human assignment and agent delegation. win.sh describes a company operator that monitors metrics, turns goals into projects and routes the work under authority rules. Neither starting point removes the need to decide who reviews a result or which actions require permission.

Roma keeps people and agents on the same item

Roma's shared-list documentation gives Assigned to and Delegate different jobs. One identifies a person, while the other sends work to the Operator or an external agent. A task includes its conversation, work in its body and a Log of edits.

This fits a founder who delegates a research item but keeps a colleague responsible for the outcome. Shared-task participants can read the conversation and answer the connected agent. They have a record tied to the particular job, not only an ongoing relationship with an assistant.

Roma adds scheduled automations, correctable memory and clients that support offline list edits. Its public docs do not describe an agent-owned goal with a measurable target. You can use task properties to organize work without assuming an agent will monitor an outcome and decide that another project is necessary.

win.sh uses business signals to select work

The win.sh how-it-works page describes reviewing metrics and producing projects from a goal, including deadlines and priorities. One company operator routes work within an authority matrix. That fits a founder who wants to set a business outcome and receive proposals about what should happen next.

Its company knowledge stores decisions, operating rules and lessons, and local loops keep journals. The public pages do not document restoration of notes or separate memory scopes for agents, projects, goals, teams and the workspace. Evaluate the knowledge record you would consult after an incorrect operating rule affects later work.

win.sh also publishes task delegation and local records of briefs, approvals and outcomes. Its public pages do not describe a shared task record with named human or agent ownership and complete history. A metrics-led plan and a colleague's assigned job therefore need separate inspection during evaluation.

Putting recurring instructions into operation

Roma's automation guide describes rehearsing tools with the Operator and reviewing a card containing steps and a schedule. You can change the proposal before approving and enabling it. A numbered playbook can direct each run, with results retained afterwards.

The win.sh local harness guide describes editable loop contracts with triggers, authority and verification. Loops can select their next useful run time, and the published bug-fix loop defines executor steps and follow-up conditions. This is useful when the next check should depend on the loop's state.

For a recurring operations brief, Roma gives you a proposed automation to approve. win.sh gives you a loop contract to inspect, including when it should return. Roma's task-event polling can wake your connected external agent, while win.sh's local harness runs coding agents in your repository.

Check the tool boundary before choosing either route. Roma's custom MCP documentation restricts automation runs to custom servers' reading tools. win.sh's catalog marks custom API and custom MCP soon, while other pages describe custom enterprise integrations. Confirm availability for your account before making a required connector part of the plan.

Permission before action, checks after delivery

Roma's permission guide offers Always allow, Ask first and Never for Operator actions. Approval cards appear in chat, and automations have per-app and per-action permissions within connection settings. The mechanism lets you decide whether a tool call requires intervention.

win.sh sets authority by type of work. Approvals, edits and rejections can become operating rules, but its pages do not establish separate action controls for each agent. The Bug Autofix contract can propose more authority after at least 10 successful fixes and other checks, a specific upgrade process that is not documented as tied to approval history.

Permission and correctness answer different questions. Roma's agent-work guide says connected agents leave work and updates on the task and leave completion to you. Its docs do not describe checking the result against defined acceptance criteria. The win.sh bug-fix loop asks for regression tests and checks error rates after deployment, though it does not document independent checks for every task requirement.

For repository work, keep the built-in and external-agent scopes distinct. Roma's GitHub Operator writes text files through pull requests but runs no builds or tests. A connected external agent is a separate execution choice and should be evaluated on its own capabilities.

Costs and execution need separate decisions

Roma's pricing address does not publish monthly service plans, included model usage or usage rates. Its US App Store download is listed as Free, which does not establish the cost of running the service. Claude delegation uses a paid Claude plan, separate from the Operator.

The win.sh pricing page lists self-serve monthly budgets from $50 to $10,000 with a hard limit and optional top-ups. Hosted execution and the local harness are both published options. Verify the intended execution path before deciding what your budget must cover.

Roma and win.sh, point by point

This table places the products' answers to the same questions together. Each answer carries its source and check date, including the limits behind the label.

Both columns answer the same questions from each company's public pages. Yes means the company publishes the capability the question asks about, Partly means something narrower, No means it says it does not offer it, and Not published means its public pages do not describe it. Every answer links to its source and shows when we last checked it. The oldest check on this page was November 13, 2026.

Roma and win.sh compared, with the source and check date of each answer
What you compare Roma win.sh
Goals Roma Not published

Roma documents tasks and lists with custom properties. Its public docs do not describe an owned goal with a measurable target that an agent monitors and acts on.

win.sh Yes

win.sh monitors business metrics, takes a goal and creates a plan with projects, deadlines and priorities. Its company operator routes the work under your authority rules.

win.sh/how-it-works
Leads Roma Not published

Shared lists have owners, and tasks can name a person or delegate. Its docs do not describe lead roles that review and coordinate a project, goal or team.

win.sh Yes

The company operator reviews metrics, routes work and creates projects from goals. Its pages do not describe distinct goal, project and team leads with their own coordination responsibilities.

Tasks Roma Yes

Assigned to names a person, while Delegate hands a task to the Operator or a connected agent. Each task keeps its own conversation, work in its body and a Log of edits.

win.sh Partly

win.sh lists task delegation, and the local harness records briefs, approvals and outcomes. Its public pages do not describe a shared task record with named human or agent ownership and complete history.

Recurring work Roma Yes

Automations run on schedules or after completion. List changes and delegation events wake connected agents through polling or webhooks, including changes made through the API.

win.sh Yes

Schedules, events and signals can start a run, and local loops choose their next useful run time. The documentation does not describe a stable root task with a separate task for every occurrence.

win.sh win.sh/docs/local-harness
Workflows Roma Yes

An automation can follow a numbered playbook on every run, such as reading issues, checking mail and writing a brief. Each run keeps its result, and you approve the steps before switching it on.

win.sh Yes

Editable loop contracts specify triggers, authority and verification, and the bug-fix loop defines ordered executor steps, conditions and follow-up. The documentation does not describe independent verifiers for individual steps.

Autonomy Roma Yes

Operator actions can be Always allow, Ask first or Never. Approval cards appear in chat, and automations have their own per-app and per-action permissions within your connection settings.

win.sh Yes

An authority matrix sets what each type of work can do alone or send for approval, and the company operator follows those rules. Current pages do not establish separate action settings for each agent.

Learned autonomy Roma Not published

You can change permissions or choose Always allow on an approval card. Its docs do not describe Roma proposing permission changes from your approval history.

win.sh Partly

Approvals, edits and rejections become operating rules, and Bug Autofix can propose more authority after at least 10 successful fixes and other checks. The documented upgrade proposal is not tied to approval history.

win.sh github.com/…/LOOP.md
Memory Roma Yes

Roma builds an account-level journal and profile from tasks, conversations and connected apps. You can read the profile and correct it on the Memory page, and later replies use the correction.

roma.app/learn/memory
win.sh Yes

win.sh saves decisions, rules and learnings as editable company knowledge, and local loops keep journals. Its pages do not document restoring notes or separate agent, project, goal, team and workspace memory scopes.

Planning Roma Yes

You can discuss an automation with the Operator, which rehearses its tools and proposes a card with the schedule and steps. You can request changes before approving the card and enabling the automation.

roma.app/learn/create-an-automation
win.sh Yes

Conversational onboarding analyzes a website and creates a 30-day plan, and a goal becomes projects. The pages do not describe reviewing acceptance criteria before each agent task starts.

Intake Roma Yes

Forwarded email from trusted senders becomes a task on your account's Tasks list. The REST API also creates items on a specified list, and tasks can then be delegated to an agent.

win.sh Partly

win.sh describes support issue triage, and its hosted API documents snapshot reads. The API says hosted write endpoints are not public yet, and the cited pages do not establish routing incoming requests to an owner or agent.

Connectors Roma Yes

Roma accepts custom remote Model Context Protocol servers, publishes a REST API and sends filtered list-change events to agents by webhook or polling. Automation runs can use custom servers' reading tools only.

win.sh Partly

The catalog marks Stripe, Plausible and Google Search Console live, but marks GitHub, custom API and custom MCP soon. Other win.sh pages say GitHub is available and enterprise customers can add custom integrations, so availability is unclear.

win.sh/integrations win.sh/pricing
Models Roma Not published

Roma connects to external agents, and its developer guide says it cannot set a cloud agent's model or reasoning. Its docs do not describe automatic model selection per task or step by Roma.

roma.app/developers
win.sh Partly

The public model router recommends a model and fallback using task, quality, speed and price. Its documentation does not establish that hosted workflows automatically choose a model at each step.

win.sh/ai-model-router
Cloud or your own computer Roma Yes

Operator automations run on Roma's servers. Connected agents can instead listen for work on your laptop or server through the documented polling loop. The own-computer option uses your external agent, not a local Operator.

win.sh Yes

win.sh offers hosted managed execution or an open-source local harness that runs Codex or Claude Code in your own repository.

Your own subscription Roma Partly

Roma can delegate tasks to Claude using your paid Claude plan. This covers the connected agent's work, not Roma's Operator, for which its docs describe no subscription connection or provider-key option.

win.sh Yes

win.sh's local harness lets you run loops with your own agent subscription using Codex or Claude Code.

Pricing Roma Not published

The US App Store lists the iPhone download as Free. Roma's reviewed public pages do not publish service plan prices, included model usage or usage rates, so a monthly service cost is unverified.

win.sh Yes

Self-serve monthly budgets range from $50 to $10,000, with a hard limit, optional top-ups and a seven-day money-back guarantee.

win.sh/pricing
Correctness Roma Partly

Connected agents leave work and updates on the task, and their instructions leave completion to you. Its docs describe no result checks against defined acceptance criteria, rubrics or tests.

win.sh Yes

Bug Autofix asks for regression tests and checks the error rate against defined success and failure criteria after deployment. It does not document independent pass, fail or uncertain checks for every task requirement.

github.com/…/LOOP.md

For software work

Roma and win.sh compared, with the source and check date of each answer
What you compare Roma win.sh
Code review rules Roma Not published

The GitHub Operator reads a repository's root AGENTS.md and follows its conventions when writing files. Its docs do not describe reviewing code changes against repository rules.

roma.app/learn/github
win.sh Not published

Bug Autofix directs the agent to add a regression test and run checks. The public pages do not describe reviewing changes against discovered repository rules or screening proposed rules against examples.

github.com/…/SKILL.md
Adversarial review Roma Not published

Roma offers a Devil's Advocate expert for discussing ideas. Its docs do not describe an independent second review of risky code changes.

win.sh Not published

Bug Autofix asks for risk notes and tests. The public docs describe no independent two-reviewer adversarial review for high-risk changes.

github.com/…/SKILL.md
Risk rating Roma Not published

The GitHub Operator can open and merge pull requests when asked, with approval cards for those actions. Its docs do not describe a risk rating before merge.

roma.app/learn/github
win.sh Partly

The bug-fix executor reports remaining risk and test output with a pull request or patch. It does not document a merge-risk rating for the exact revision.

github.com/…/SKILL.md
Pull requests Roma Partly

The GitHub Operator opens file writes as pull requests and can read reviews and update pull requests. Its docs do not establish an agent loop addressing review feedback, and the Operator runs no builds or tests.

roma.app/learn/github
win.sh Partly

Bug Autofix instructs its local executor to open a pull request or provide a patch, and requires approval before merge. Its public contract does not describe exact-commit approval or addressing review feedback.

A fact we cannot find or cannot check is left out, and prices can change after the date shown. Task Machine publishes this comparison and is an interested party. Roma and win.sh are named only to identify them, and there is no relationship between the companies. Has something changed? Tell us.

Who each one suits

Pick Roma if your team needs shared task lists that distinguish a responsible person from the agent doing delegated work. Its public docs do not describe measurable agent-owned goals, and the monthly service cost remains unverified.

Pick win.sh if you want an operator to watch metrics and create projects under standing authority rules. Its public pages do not describe a complete shared ownership record, and connector availability needs confirmation where its pages disagree.

Where Task Machine fits

Task Machine connects the two starting points through Goals with linked Metrics and leads, alongside Tasks that people or agents own. Its Goals documentation describes leads reviewing progress and proposing missing work for approval. Workflows add explicit branches and verifier checks when the recurring process needs a defined return path for failed output.

Task Machine is the wrong pick if your main need is Roma's offline list capture or a single company operator's adaptive loops. Read Task Machine vs Roma and Task Machine vs win.sh, then take one business metric and identify the shared task, decision boundary and evidence that should follow from it.