Whenever (by Wix) alternative to Gumloop: Agents Only Where the Job Needs Them

Why buyers actually switch from Gumloop to Whenever (by Wix)

Most teams arrive at this page after running a few agents on Gumloop and noticing that the work they most need to be reliable is the work that varies most from run to run. The switch is rarely about one missing button. It is about a different bet on how automation should execute. Here are the specific reasons teams cite.

1. They want the same input to produce the same output. Whenever's core promise is that AI writes the workflow once, then code runs it. A workflow that reconciles invoices, syncs CRM records or routes tickets runs the same fixed logic on run 1 and run 10,000, given the same inputs and dependencies. Gumloop's business agents choose tools with a model at runtime, which is powerful for open-ended tasks and less predictable for fixed rules.

2. They want to reason about cost per run, not per step. Whenever bills per run, not per step. A 40-step workflow and a 4-step workflow cost the same to execute. Gumloop's agent-chat credits combine model usage, tool calls, active compute and orchestration, so the cost of a single chat depends on how the agent decides to work.

3. They want polling that does not bill before work starts. Gumloop's AI-generated polling triggers are saved as code and billed each poll even if the agent does not start. Teams that check a queue every minute feel that. Whenever's webhook and app-event triggers start a run only when something happens.

4. They want the workflow to leave the platform. Every Whenever workflow is an exportable, readable TypeScript module. Gumloop's agent-version API exports configuration but not skill files. If your team reviews automation in pull requests, that difference is the whole argument.

5. They want to build where they already work. Whenever supports building in the app or over MCP from Cursor, Claude Code or Codex. Developers who live in an editor do not have to context-switch to ship a workflow.

None of this makes Gumloop a poor product. It makes it a different product. Gumloop runs the whole job through an agent; Whenever runs fixed steps as code and calls an agent only where the job needs judgment.

Try Whenever (by Wix) free

Deep dive: deterministic execution vs runtime tool choice

The single biggest architectural difference is what happens after the workflow is designed.

How Whenever runs a workflow

You describe the job in plain words. The AI builds the workflow and asks about business rules: the exceptions, the thresholds, the fields that must be present. Then it writes the workflow as code. From that point, fixed, non-AI logic with the same inputs and dependencies runs the same way every time, and optional AI steps add a model call only where you put one. You can add AI steps where you want them: a classification step, a summarization step, an extraction step. Whenever runs agents as a step: an agent loop with the tools you give it and a capped number of turns, inside a run of up to an hour, next to fixed steps in the same workflow.

How Gumloop runs an agent

Gumloop supports business agents that choose tools with a model and use shared knowledge. That design is well suited to tasks where the right next step depends on what the agent finds. The trade-off is that the path through the workflow is decided at runtime, which makes exact replay harder and makes cost depend on the decisions the model makes.

Why the difference matters in production

When a finance workflow fails at 2 a.m., you want to know which step failed and why. Whenever logs every run and every step (7 days on Hobby, 30 days on Pro), with an email when a run fails, so you can open the run and see the exact step. With runtime tool choice, the same failure can be a different sequence of decisions each time, which makes root-cause analysis a different kind of exercise.

Deep dive: per-run billing vs credit-based agent chat

Pricing models shape behavior. A per-step or per-credit model encourages teams to consolidate workflows; a per-run model encourages teams to make each run do more.

What a run includes in Whenever

Whenever bills per run, not per step. On Pro at $39/mo (or $29/mo billed yearly) you get 10,000 runs per month, unlimited workflows, every-minute schedules and $10 of included runtime AI spend. On Hobby at $0 you get 100 runs per month, 1 active workflow, hourly schedules and $1 of included runtime AI spend. AI building is free within weekly usage limits.

What a Gumloop agent chat includes

Gumloop agent-chat credits combine model usage, tool calls, active compute and orchestration. BYOK changes model charges. That is a coherent way to price agent work, because agent work genuinely consumes different amounts of compute. It also means the cost of a chat is not fixed in advance.

The practical consequence

If your workflow has 30 steps and runs 8,000 times a month, a per-run unit gives you a number you can put in a budget. If your workflow is an open-ended research agent, a credit model may better reflect what you actually consume. The question is which shape your work has.

Deep dive: exportable TypeScript vs configuration export

Portability is the quiet reason teams switch. Automation that cannot leave the platform becomes a platform decision, not a tooling decision.

What you get from Whenever

Each workflow is an exportable, readable TypeScript module. That means you can commit it, review it and diff it. It also means a new engineer can read the workflow without learning a proprietary canvas. Combined with MCP support for Cursor, Claude Code and Codex, the workflow lives where your code lives.

What you get from Gumloop

Gumloop's agent-version API exports configuration but not skill files. Configuration export is useful for backup and for recreating an agent, but it is not the same as a readable code module you can review and version.

Where this shows up in practice

Teams that require code review for anything touching production data will ask for the export on day one. If the answer is "configuration only," the workflow stays where it was built.

Who this is actually for

Whenever fits the stable, repeatable part of the work: fixed rules run as code, with AI steps only where you add them. It does not replace every knowledge-driven agent. Three concrete scenarios:

Scenario 1: A 6-person RevOps team running lead routing

Leads arrive by webhook, get enriched, scored against fixed rules, assigned to a rep and written to the CRM. The rules change monthly, not hourly. The team needs every run to behave the same way and needs to explain any assignment to a sales leader. Whenever's deterministic execution and step-level logs fit this directly. Gumloop's shared-knowledge agents are a better fit when the routing decision itself is open-ended.

Scenario 2: A platform team that reviews automation in pull requests

The team already uses Cursor and Claude Code. They want workflows as TypeScript modules they can review and version. Building over MCP and exporting each workflow as a readable module matches their existing process. Gumloop's agent-management controls and evaluations are the stronger fit when the team is managing many reasoning agents rather than many fixed pipelines.

Scenario 3: A finance ops team with a high-volume, many-step reconciliation job

The job has 30+ steps and runs thousands of times a month. Per-run billing makes the cost predictable, and the deterministic execution makes the output auditable. If the job instead required judgment calls at each step, Gumloop's runtime tool choice and human approvals would be the more natural design.

How to migrate from Gumloop to Whenever (by Wix)

Migration is mostly a translation exercise: you already know the business rules, which is the hard part.

1. Inventory your Gumloop agents. List each agent, its trigger, its tools and whether its decisions are fixed rules or genuine judgment calls. Sort them into "deterministic" and "agentic."

2. Start with the deterministic ones. These are the workflows where the same input should produce the same output. They migrate cleanly and deliver the fastest reliability win.

3. Describe each job in plain words in Whenever. The AI builds the workflow and asks about business rules. Answer the exception questions carefully. This is where your institutional knowledge gets encoded.

4. Map integrations. Whenever has 1,400+ integrations plus any API with docs. Check each Gumloop tool against that list; anything missing can be called through its API if it has docs.

5. Recreate triggers. Replace Gumloop polling triggers with Whenever schedules, webhooks, app events or on-demand triggers. Each scheduled execution counts as a Whenever run.

6. Add AI steps only where needed. Keep classification, extraction and summarization as explicit AI steps inside an otherwise deterministic workflow.

7. Run both in parallel for one cycle. Compare outputs on real data. Whenever's step-level logs make the comparison straightforward.

8. Export and commit. Once a workflow is stable, export it as a TypeScript module and commit it to your repo so it is reviewable.

9. Cut over and monitor. Keep the Gumloop agent paused for one billing cycle before retiring it, in case an edge case surfaces.

For teams comparing more automation platforms, this comparison is published with Alt Hunt, which tracks alternatives across the category.