Hyperagent vs win.sh: Two Ways to Let Agents Run
Hyperagent builds living deliverables from a prompt. win.sh runs a 24/7 loop inside rules you set. A neutral matchup, and a third option that keeps you in the loop.
Founder, Task Machine
Two products let AI agents run real work against the accounts you already own, both take no cut of your revenue, and both are serious. They disagree about the one thing that decides how the tool feels day to day: what an agent is for. Comparing Hyperagent and win.sh forces a question most buyers skip past, which is not which tool does more but what you want an agent to hand you.
Hyperagent, built by Airtable, is prompt-first. You brief an agent and it researches, builds, and then maintains a living deliverable, a website, a dashboard, a video, a document, that updates itself as circumstances change. win.sh is loop-first. There is no single artifact. The system monitors your business around the clock, proposes the next move, acts only inside rules you set through a per-work-type authority matrix, and reports each morning via Telegram with a Decisions tab to review. One hands you a thing that stays current. The other hands you a company that runs on a schedule.
The same accounts, opposite mechanics
Put side by side, the two agree on ownership and diverge on almost everything else.
| Dimension | Hyperagent | win.sh |
|---|---|---|
| What an agent produces | A living deliverable it builds and maintains | Actions in a continuous monitor-and-act loop |
| How you start work | Prompt-first: brief an agent, it builds | Rule-first: set an authority matrix, it runs |
| Your role | Brief and review the deliverable | Set rules and review the morning brief |
| How autonomy is granted | High by default, inside the agent's task | Gradually, per work type, as your reviews become operating rules |
| How work is checked | Evals that score output to improve the agent | Approval gates on spend, outreach, and sensitive changes |
| Your accounts | Agents authenticate into systems you own | Connected accounts you own (Stripe, Shopify, GitHub, and more) |
| Execution | Each agent in its own cloud environment | Cloud sandboxes running a 24/7 loop |
| Backing | Airtable, launched early 2026 | Independent, self-serve |
| Revenue | No cut, usage-based, per-task or per-agent | No revenue share, no withdrawal fee |
Neither column is a trap. Both avoid the custody-and-revenue-cut model that defines platforms like Polsia, where the vendor provisions your Stripe and takes a percentage. The choice between these two is about what you want back.
Who Hyperagent suits
Hyperagent fits people whose work has a clear finished shape. If what you need is a site that reflects this week's inventory, a dashboard that refreshes, or a recruiting page that stays live, the deliverable-first model meets you there. You describe the artifact, an agent builds it, and it keeps the thing current without you re-briefing.
It also fits buyers who value the backing. Airtable's resources mean the polish, the integrations, and the onboarding are likely to keep improving quickly, and the model-agnostic support across Claude, ChatGPT, and Gemini is broad. The evals are a real advantage when an agent can grade its own output and improve on the next pass.
The cost is that the unit of work is an artifact. When the work is a recurring operation with judgment scattered through it, an outreach sequence, a client report, a support queue, you are fitting a process into a shape built for a thing, and the review happens after the agent produces the result rather than before it ships.
Who win.sh suits
win.sh fits people who think in rules. There are no artifacts to brief, just a system that watches the business, proposes moves, and earns wider authority as your reviews accumulate into operating rules. The authority matrix is the most thoughtful autonomy mechanism in this lane, because it makes trust granular and reversible per work type rather than global.
It also fits people who want ownership without much involvement. Everything runs against accounts you own, spend has a hard cap with receipts, and risky moves stop for approval. The daily rhythm is light: read the brief, review the Decisions tab, adjust the rules.
The cost is that the loop is retrospective. It runs before you ask, which is the pitch, and it means your control is exercised mostly after the fact. If work in flight goes somewhere you would not have taken it, you learn that in the morning.
The third option: steer instead of brief or review
Both products assume you want distance from the work, and they build different kinds of it. Hyperagent gives you a finished artifact so you do not touch the process. win.sh gives you a morning brief so you do not touch the run. There is a third position: no distance, but less labor. You stay the operator, agents do the work, and the judgment calls come to you before they ship rather than after.
Task Machine is built for that position. Work runs through three connected surfaces: chat to set direction and fan work out, an inbox where approvals, questions, and failed checks land for a decision, and tasks for the detailed back-and-forth on one piece of work. Recurring work runs as deterministic workflows, explicit graphs with branch conditions, human-question nodes, approval nodes, and verifier nodes, with step-level logs you can open and read instead of a summary to trust or a deliverable to inspect. Autonomy exists here too, set as a level per kind of work, and budgets cap spending, so routine chores run ahead while client-facing or money-touching work waits at your inbox.
The contrast with Hyperagent's evals is worth stating plainly, because both tools check work. An eval scores an agent's output to make the agent better. A verifier in Task Machine is a gate: when it fails, it creates inbox work, and a person decides what happens before anything moves forward. One improves the worker, the other holds the run for a human.
The trade is the mirror image of both rivals: more setup than a single prompt or a template, less unprompted activity than a loop that runs before you ask, and an inbox that expects you to show up. In exchange, nothing client-facing ships without you, and every run is inspectable at the step level.
Choosing among the three
- Choose Hyperagent if the work is a deliverable you want an agent to build and keep current, prompt-first autonomy suits the stakes, and you value the platform Airtable is backing.
- Choose win.sh if you want maximum autonomy against accounts you own, with rules instead of prompts, and a morning brief is enough oversight for your risk level. It is the most polished autonomy-first product in this lane.
- Choose Task Machine if the work is often client-facing or hard to undo, and you want to steer it in flight through chat, an inbox, and tasks, with runs you can verify step by step.
For the direct product comparison with the deliverable side of this matchup, read Task Machine vs Hyperagent. And if the third option is the one you were missing, join the private beta on the waitlist.