Gumloop vs Make: Where Should the Agent Work?
Compare Gumloop agent tasks with Make scenarios on approvals, model selection, result checks, hosting and credit charges.
Founder, Task Machine
Do Gumloop or Make give your team the right place to direct an agent, inside its own task or inside a scenario? Gumloop turns each agent job into a task with a conversation, files, history and credit cost. Make runs agents on task inputs within scenarios and records scenario runs.
That difference matters when a report needs several rounds of discussion or an incoming event needs a defined route through app actions. Both products publish tools for agent work and human review, so the choice cannot rest on whether either has added an approval feature.
Gumloop starts with an agent job
Gumloop's agent documentation describes agents that use tools and delegate parallel work to specialized subagents. Each job has its own conversation and supporting files. A team investigating a customer issue can keep the agent's work attached to that particular request.
You can also develop a process through conversation and save it as a skill. Create With AI produces instructions, scripts and reference files that an agent can use later. This gives repeated work a reusable artifact beyond the original conversation.
Gumloop still offers predictable sequences. Its Flows explanation describes conditional paths with agents inside them for open-ended decisions. Its pricing page labels this feature Workflows (Legacy), a naming detail worth noticing if your evaluation begins with older canvas-based material.
Make puts agents in scenarios
Make's AI Agent introduction describes agents that use modules, scenarios and Model Context Protocol tools. Scenarios connect app steps, and routers branch according to conditions. You can retain a specified route while giving an agent tools for an input that needs judgment.
Make's AI Agent app is in open beta. Its Maia documentation also describes Plan mode, which previews a proposed scenario for acceptance, rejection or revision before construction. That review concerns building the scenario, not acceptance criteria for each later agent job.
The scenario model fits work where the route itself needs inspection, such as receiving a request, categorizing it and passing data to another system. Make's public docs do not describe a shared job record that a person or agent can own interchangeably. Choose the record your team will actually use to investigate an exception.
Approve tools or configure a review step
Gumloop's human review documentation lets you allow, block or require approval for individual tools and add conditional guardrails. Its notification inbox collects Approve and Reject actions. Tasks also has an Approval Required filter across agents.
Make's agent guidance describes adding a tool that sends an output to a person before the agent continues. The published example uses Slack to confirm an email draft or request changes. This is a configured review tool, so design the path that gets the draft to its reviewer.
For a customer-facing reply, distinguish permission to use a sending tool from approval of the final wording. Gumloop publishes controls at the tool boundary, while Make describes a review tool in the agent's process. During evaluation, reject a draft and observe where that response appears before allowing the sending action.
Grade the result and inspect the record
Gumloop's Evaluations documentation describes grading completed tasks against criteria you define. Each criterion can receive an explanation, and configured flags or notifications can surface a failure. These checks run after completion and exclude incognito chats and internal system interactions.
Make describes inspecting module outputs and logs, alongside the review tool for agent outputs. Its docs do not establish checks against defined result criteria or automatic return of failed work for revision. A log can help you investigate an answer, but your evaluation still needs a named reviewer and a decision about delivery.
For a weekly summary, specify whether the check must happen before anyone receives it. Gumloop's post-completion grade and Make's configured human review occupy different points in that timeline. Test the delivery boundary separately from whether an execution has finished.
Select models and account for usage
Gumloop's model documentation says Auto selects a model for each message using task difficulty, required tools and how the answer can be checked. It can move to a stronger tier mid-run, or you can pin a model. Make lets you select a provider and model for an agent and configure a fallback provider connection, but its docs do not describe automatic selection for each stage against budgets.
Gumloop's pricing page lists Pro at $37 a month with 20,000 monthly credits. Its credit documentation describes models, tools and compute plus an 8% orchestration fee, normally 16% with your own provider keys. Supported provider keys are available on Pro and higher plans for eligible model calls, while tools, compute and orchestration remain chargeable.
Make's credit documentation charges operations and, for some AI features, token usage. A Google Drive file upload uses 1 credit, while some modules use 2 or 10 credits per operation. With custom provider connections, you also pay the provider for tokens, so neither product's credit count can be substituted for the other's.
Gumloop and Make, point by point
Both products answer the same questions below. The rendered table includes the source and check date for each answer, including narrower capabilities and publication limits.
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.
| What you compare | Gumloop | Make |
|---|---|---|
| Goals |
Gumloop
Partly
Agents accept goals and use tools to complete work. Its docs do not describe an owned goal with a measurable target and progress review. |
Make
Partly
Make agents follow instructions that include goals, and Enterprise analytics shows scenario metrics and trends. Its docs do not establish a goal with an owner and linked measurable target that the owner reviews or acts on. |
| Leads |
Gumloop
Partly
An agent can delegate parallel work to specialized subagents and collect their results. Its docs describe coordination within a task rather than a lead role overseeing a project, goal or team. |
Make
Partly
Make organizes people into teams and describes agents that categorize and assign support tickets. Its docs do not establish a named lead or owner role that reviews and coordinates work for a project, goal or team. |
| Tasks |
Gumloop
Partly
Each job given to an agent becomes a task with its own conversation, history, files and credit cost. Its docs do not describe assigning those same work items to people as owners. |
Make
Partly
Make runs agents on task inputs inside scenarios and records scenario runs. Its docs do not describe a shared job record owned interchangeably by a person or an agent. |
| Recurring work |
Gumloop
Yes
Agents run on recurring or one-time schedules, app events and webhook requests. Each trigger has a configurable prompt and a view of its recent tasks. |
Make
Yes
Scenarios run once, on schedules, on demand or from instant webhook triggers, and scenario history records runs. The docs do not describe a stable root Task with a separate status for each occurrence. |
| Workflows |
Gumloop
Yes
Flows run predictable steps with conditional paths and can include agents for open-ended decisions. The pricing page lists this feature as Workflows (Legacy). |
Make
Yes
Scenario routers branch by conditions, and Make describes adding a review tool for agent outputs. Its docs do not describe built-in acceptance-requirement verifier checks that return weak work for revision. |
| Autonomy |
Gumloop
Yes
You can allow, block or require approval for individual tools and add conditional guardrails. The notification inbox collects requests with Approve and Reject actions, and Tasks has an Approval Required filter across agents. |
Make
Yes
Make describes adding a tool that sends agent output to a person for review before the agent continues. This configured review differs from an agent-wide per-action ask-first or automatic setting. |
| Learned autonomy |
Gumloop
Partly
Reflections review task history and propose evidence-linked changes to skills, instructions and triggers. Its docs do not describe proposing permission changes from approval history. |
Make
Not published
Maia can save preferences and lets you approve scenario plans. Make's searched documentation does not describe proposing agent permission changes from approval and correction history. |
| Memory |
Gumloop
Yes
Gumball uses personal memory across conversations, including context learned from custom-agent chats. You can inspect memory cards, rewrite summaries, archive, restore or forget them. Only Gumball can read that personal memory. |
Make
Yes
Maia saves preferences that you can add, edit or delete, and agents can retain conversation context and use knowledge files. The docs do not describe restorable lessons scoped to agents, projects, goals, teams and workspaces. |
| Planning |
Gumloop
Yes
Create With AI turns a conversation into a saved skill with step-by-step instructions, scripts and reference files. You can attach the resulting skill to an agent for later work. |
Make
Yes
Maia's Plan mode previews a proposed scenario for you to accept, reject or revise before building. It describes planning scenario construction rather than reviewing acceptance criteria for an agent-owned task. |
| Intake |
Gumloop
Yes
A webhook gives a selected agent its own URL, and incoming requests start that agent with the payload or a configured prompt. App triggers also route outside events into agent work. |
Make
Yes
Custom webhooks receive data over HTTPS and start scenarios, and Make describes an agent that categorizes and assigns support tickets. Its docs do not describe this as a project-token task intake with proposal approval. |
| Connectors |
Gumloop
Yes
Agents use built-in connectors, custom Model Context Protocol servers and API calls saved as skills. App events and webhook requests can trigger agents. |
Make
Yes
Make agents use modules, scenarios and Model Context Protocol tools, and webhooks receive external events. Its docs do not describe installing command-line tools as connectors. |
| Models |
Gumloop
Yes
Auto chooses a model for each message using task difficulty, required tools and how the answer can be checked. It can switch to a stronger tier mid-run, and you can instead pin a model. |
Make
Partly
You select an AI provider and model for an agent, and can configure a fallback provider connection. Its docs do not describe choosing a model automatically for each stage against budgets. |
| Cloud or your own computer |
Gumloop
Yes
Agents have a hosted, isolated computer for Python and shell commands. Enterprise customers can deploy Gumloop inside their own AWS, Azure or Google Cloud environment. |
Make
Partly
Make runs automations in its cloud and offers Enterprise customers an On-premise agent for accessing local applications and databases. The local option currently supports only the HTTP Agent application. |
| Your own subscription |
Gumloop
Partly
Pro and higher plans accept supported provider API keys for eligible model calls. A key covers only models served through that provider, while tools, compute and the orchestration fee remain chargeable. |
Make
Partly
Make's custom AI provider connections link OpenAI, Anthropic or Gemini accounts using API keys, with token usage paid to the provider. Custom connections require a paid plan, and some AI features offer no provider choice. |
| Pricing |
Gumloop
Yes
Pro costs $37 a month with 20,000 monthly credits. Usage covers models, tools and compute, plus an 8% orchestration fee, normally 16% with your own provider keys. Enterprise pricing and credits are custom. |
Make
Yes
Make charges credits based on operations and, for some AI features, token usage. A Google Drive file upload uses 1 credit, while some modules use 2 or 10 credits per operation. With custom AI provider connections, customers also pay their provider for tokens. |
| Correctness |
Gumloop
Yes
Evaluations grade completed tasks against criteria you define, with per-criterion explanations and configured flags or notifications. They run after completion and exclude incognito chats and internal system interactions. |
Make
Partly
Make describes adding a review tool for agent outputs and inspecting module outputs and logs. Its docs do not establish checks against defined criteria for results or automatically returning failed work for revision. |
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. Gumloop and Make are named only to identify them, and there is no relationship between the companies. Has something changed? Tell us.
Who each one suits
Pick Gumloop if shared agents, reusable skills and tool-level approvals match how your team works. Its evaluations happen after completion, so configure a separate approval if the result must be checked before delivery.
Pick Make if a visual scenario should connect app actions and give an agent selected tools inside that route. Account for the AI Agent app's open beta status and build the review path your output needs.
Where Task Machine fits
Task Machine centers the job's owner and acceptance requirements. A Task can belong to a person or agent, and you review the plan before an agent starts. Task reviews check each requirement against delivered work before a person reviews it, while Workflow verifiers can return weak work with feedback.
Task Machine is the wrong pick if the requirement is to keep editing Make scenarios or if Gumloop's shared agents already provide the needed control. Read the Gumloop comparison and Make comparison for the ownership and checking boundaries. Use one customer-facing draft to test who owns the job, who approves sending it and what happens when a check fails.