Gumloop pricing: what do 5k free credits vs 20k+ Pro credits cover for real workflows?

“Can we actually run our real workflows on the Free plan, or do we need to jump straight to 20k+ Pro credits?”

If you’re asking that, you’re already in the right headspace: thinking in workflows and artifacts, not just “playing with AI.” Credits only matter insofar as they turn into tickets created, CRM records updated, briefs generated, or reports shipped.

Quick Answer: 5k free credits are more than enough to prove out 2–4 serious workflows and get them running on light, real traffic (think: a Support Agent triaging a subset of tickets or a Meeting Prep Agent for a few execs per week). 20k+ Pro credits are where you move from “this works” to “this is a production agent” with higher volume, more frequent schedules, and more concurrent runs—without constantly worrying about hitting the ceiling.

Why This Matters

If you’re evaluating Gumloop, you’re not trying to benchmark models—you’re trying to offload work. That means understanding what 5k vs 20k+ credits actually buys you in terms of:

• How many tickets your Support Agent can triage in Zendesk.
• How many CRM updates your Sales Ops workflow can push to Salesforce.
• How many meeting briefs, call analyses, or data digests your team can rely on weekly.

Getting this wrong either leads to overbuying (credits you never touch) or sandbagging (agents that stall the second your team actually uses them).

Key Benefits:

• Predictable ramp-up: Use 5k free credits to validate 2–4 real workflows end‑to‑end before paying anything.
• Production headroom with Pro: 20k+ Pro credits let you roll out agents to teams (support, sales, ops) with enough volume to matter.
• Operational guardrails: On Pro and Enterprise, credits sit inside real governance—RBAC, usage analytics, audit logs—so you can treat this like infrastructure, not a toy.

Core Concepts & Key Points

Concept	Definition	Why it's important
Credit	The unit Gumloop uses to meter AI + workflow execution. Each agent reasoning step, tool call, and workflow run consumes credits.	It’s the real “currency” behind your agents—knowing how credits map to workflows lets you forecast cost vs impact.
Workflow Run	A full pass of a Gumloop Workflow (node-based canvas) from trigger to completion—e.g., ingest a ticket from Zendesk, enrich it, create a Jira bug, post back to Slack.	This is where value happens: a completed artifact inside Jira, Zendesk, Salesforce, or Slack. Credits fund these runs.
Triggered/Scheduled Agents	Agents wired to fire off Slack mentions, webhooks, or recurring schedules (e.g., daily warehouse digest, hourly CRM hygiene).	Triggers and schedules determine how fast you burn credits; they also define whether you’re in “pilot” mode or true production.

How It Works (Step-by-Step)

Gumloop pricing is simple on the surface:

• Free: 5k credits/month, 1 seat, 1 active trigger, 2 concurrent workflow runs, forum support, unlimited agents and workflows.
• Pro: Starts at 20k+ credits/month, unlimited seats, 5 concurrent workflow runs, unlimited teams, unified billing, team usage & analytics.
• Enterprise: Custom credits, RBAC, SCIM/SAML, audit logs, custom data retention, admin dashboard, optional Gumstack, etc.

What actually matters: how those credits translate into real work.

Here’s a practical way to think about it.

1. Estimate the “job” per workflow

   For each agent/workflow, define the job:

   • Support Agent: “Triage incoming Zendesk tickets, detect bugs, create Jira/Linear tickets, post summaries in Slack.”
   • CRM Agent: “Clean stale Salesforce/HubSpot records weekly, log missing activities, and post exceptions to RevOps in Slack.”
   • Meeting Prep Agent: “Before each exec meeting, pull context from Gmail, calendar, Salesforce, and prior notes and post a brief to Slack.”
   • Data Analysis Agent: “Answer ad-hoc questions against Snowflake/BigQuery and produce a short report back in Slack.”
   • Call Analysis Agent: “Review call transcripts, flag objections/risks, and push summaries + tags into Salesforce.”

   Each “job” typically involves:

   • Some reasoning steps (LLM prompts).
   • Several tool calls (APIs to Slack, Zendesk, Jira, Salesforce, warehouses).
   • Post-processing and artifact creation (ticket, report, brief, digest).

   That’s what chews credits—not just the chat.

2. Map the job to rough monthly volume

   Now ask per workflow:

   • How many times per day/week does this need to run?
   • How many artifacts will it produce per month?

   Examples:

   • Support triage for a small team: 50–200 tickets/day.
   • Meeting prep for a small leadership team: 20–60 meetings/week.
   • CRM hygiene: daily/weekly passes over hundreds or thousands of records.
   • Data/Call analysis: tens to hundreds of questions/calls per month.

   Your 5k vs 20k decision mostly comes down to whether you’re running:

   • Low-frequency pilots on a subset of traffic, or
   • High-frequency, broad coverage across a team or org.

3. Decide what belongs on Free vs Pro

   A simple split that works for most teams:

   • Use 5k Free credits to:

     • Build and test the exact workflow.
     • Wire the real tools (Slack, Gmail, Zendesk, Salesforce, warehouses).
     • Run it against a subset of tickets, records, meetings, or calls.
     • Validate the artifact quality (e.g., Jira tickets look like a human wrote them).

   • Move to 20k+ Pro credits when:

     • Non-builders (support reps, AEs, managers) start relying on the automation.
     • You’re ready to expose the agent to most or all of your inbound work.
     • You want more concurrent runs so workflows don’t queue when traffic spikes.
     • You need unified billing across multiple teams and seats.

   From there, higher credit tiers are just an answer to “how much work do we want done by Gumloop this month?”

What 5k Free Credits Realistically Covers

You can run more than you’d expect on Free—if you’re intentional.

Below are conservative examples so you don’t get surprised.

1. Support Agent on a subset of Zendesk/Jira traffic

Target: Prove that an agent can triage and create proper bug tickets.

With 5k credits, you can typically:

• Build a Support Agent Workflow that:
  • Reads incoming Zendesk tickets (via trigger or sample webhooks).
  • Classifies issues (bug vs question vs feature).
  • For bugs, creates Jira/Linear tickets with:
    • Summary
    • Steps to reproduce
    • Severity
    • Tags (product area, customer tier, etc.)
  • Posts back to Slack with links and a quick summary.
• Run this in pilot mode, for example:
  • Only on tickets in one Zendesk view (“High-value customers”).
  • Or only during certain hours (e.g., 9–5 PT).
  • Or only for specific labels (e.g., “Bug?”).

This is enough to:

• Watch Gumloop produce dozens to hundreds of real Jira tickets.
• Compare “before vs after” in your Slack support channel.
• Tune prompts and workflows without touching your budget.

2. Meeting Prep Agent for a small leadership pod

Target: Show that Gumloop can build useful briefs from Gmail, calendar, and CRM.

With 5k credits, you can typically run:

• A Meeting Prep Agent that:
  • Triggers 30–60 minutes before a meeting.
  • Pulls context from:
    • Calendar (title, attendees, past meetings).
    • Gmail/Slack (recent threads).
    • Salesforce/HubSpot (account health, opportunities).
  • Generates a Slack message like:
    • Account summary
    • Open deals and stages
    • Key risks and recent escalations
• Volume at pilot scale, for example:
  • 4–6 people on the leadership team.
  • 3–8 key meetings per week per person.
  • That’s easily dozens of briefs per month.

You’ll see whether:

• The briefing format is useful.
• The data it pulls is correct.
• The credits per brief feel worth the time saved.

3. Data Analysis Agent for ad-hoc warehouse questions

Target: Let ops/analytics leads ask questions in Slack and receive answers from Snowflake/BigQuery.

With 5k credits, you can:

• Build a Data Analysis Agent that:
  • Accepts a Slack question (“Show churn by plan for Q1 vs Q2”).
  • Generates SQL against your warehouse.
  • Executes the query.
  • Summarizes the results in 3–5 bullet points, plus a chart/table if you want.
• Run tens to low hundreds of such questions per month, depending on complexity.

This is plenty to:

• Validate schema understanding.
• Catch edge cases in SQL generation.
• Decide which teams should get wider access.

4. Light CRM hygiene and enrichment

Target: Try a CRM Agent to clean and enrich a slice of Salesforce.

With 5k credits, you can:

• Run a weekly or bi-weekly workflow that:
  • Scans a few hundred records in Salesforce.
  • Flags missing fields (industry, segment, owner notes).
  • Optionally enriches via external APIs or internal data.
  • Posts an exception report in Slack for review.
• Keep it intentionally constrained:
  • Only deals over a certain ARR.
  • Only certain stages or territories.
  • Only one team (e.g., Mid-Market).

This is enough to find out whether:

• The hygiene rules make sense.
• Sales leadership trusts the changes.
• You want to scale to all deals.

---

If you’re disciplined about pilot scope (specific queues, teams, or accounts), you can easily:

• Build 3–4 agents.
• Run them in realistic conditions.
• Stay within 5k credits while getting real artifacts (tickets, briefs, reports).

What 20k+ Pro Credits Unlock for Real Workflows

20k+ credits/month is where you stop sandboxing and start running agents as part of your operating model.

Here’s what changes when you move to Pro.

1. Roll out agents org-wide without babysitting the meter

With 20k+ credits, you can comfortably:

• Put the Support Agent on all inbound tickets, not just a narrow view.
• Give the Meeting Prep Agent to a whole leadership layer or GTM org.
• Let sales and CS teams talk to CRM and Data Analysis Agents in Slack without constantly worrying about “using up” the budget.

Practically, this can look like:

• Support triage: hundreds to low-thousands of tickets/month.
• Meeting briefs: hundreds of briefs/month across teams.
• Warehouse queries: dozens to hundreds of questions/month.
• CRM hygiene: full-funnel passes across thousands of records.

2. Run more Workflows in parallel (5 concurrent runs)

On Free, you get 2 concurrent workflow runs. That’s fine for pilots; not great when:

• A spike in Zendesk tickets coincides with a CRM hygiene run.
• Meeting prep triggers fire at the top of the hour for multiple execs.
• Data Analysis Agents are running warehouse-heavy queries.

On Pro, 5 concurrent runs mean:

• Workflows don’t back up under normal load.
• Latency feels closer to a real coworker than a batch job.
• You can run multiple high-value agents (support, CRM, meeting prep) simultaneously without stepping on each other.

3. Support multiple teams with unified billing and analytics

Pro adds:

• Unlimited Seats – anyone who needs to trigger or maintain workflows can get an account.
• Unlimited Teams – split agents/workflows by business unit (Support, Sales, RevOps, Product, etc.).
• Unified Billing – one bill, shared credits across teams, instead of fragmented accounts.
• Team Usage & Analytics – visibility into:
  • Which workflows are used the most.
  • Which teams are driving credit consumption.
  • Where optimization or guardrails are needed.

This matters when your initial pilot succeeds and suddenly:

• Support wants their own agents.
• Sales wants call analysis and CRM agents.
• Ops wants data digests and warehouse Q&A.

20k+ credits give you the budget; Pro’s features give you a way to govern it.

4. Step towards enterprise governance

Even before a full Enterprise contract, Pro is a better fit for:

• Fast-growing teams that want to standardize on Gumloop.
• Org-wide experiments where you’re likely to grow into RBAC, SCIM/SAML, audit logs, custom retention, and potentially VPC or Zero Data Retention.

When that happens, Enterprise adds:

• Role-Based Access Control – limit who can edit workflows vs just trigger them.
• SCIM/SAML Support – manage users and groups via Okta and friends.
• Admin Dashboard & Audit Logs – see who ran what, where, and when.
• Custom Data Retention Rules – align with your internal and regulatory policies.
• Gumstack (optional) – security, observability, and MCP infrastructure beyond Gumloop itself.

But the jump from Free → Pro is typically the first meaningful step into “this is infra, not a side project.”

Common Mistakes to Avoid

• Treating 5k credits as “play money”:
  If you scatter small experiments across 10 toy workflows, you’ll burn credits without proving a single production-ready agent. Instead, pick 2–4 jobs that clearly map to tickets/briefs/updates.

• Overbuilding before upgrading to Pro:
  Don’t waste months designing a perfect multi-team architecture on Free. Use Free to validate artifact quality and user behavior, then move to 20k+ when you have a clear adoption path.

• Ignoring concurrency and triggers:
  Looking only at credits and ignoring concurrent runs and active triggers can lead to workflows that technically “fit” in your budget but feel slow or inconsistent at run-time.

Real-World Example

Let’s walk a realistic scenario.

Slack message:
“@Gumloop can you handle all support triage for our top 100 accounts, prep briefs for CSM QBRs, and keep Salesforce opportunities clean weekly — but we’re not ready to spend big until we see this working?”

Here’s how a team might use Free vs Pro:

Month 0–1: Free Plan (5k credits)

You:

1. Build a Support Agent Workflow that:

   • Ingests Zendesk tickets via a single view (“Top 20 accounts”).
   • Classifies severity and type.
   • Creates Jira bugs with rich context.
   • Drops a summary in #support-escalations on Slack.

2. Build a Meeting Prep Agent for:

   • CSMs handling QBRs for those same 20 accounts.
   • Triggered manually at first (CSM tags @Gumloop in Slack).
   • Pulls from calendar, Salesforce, and prior tickets.

3. Build a CRM Agent that:

   • Runs weekly on opportunities over a certain ARR threshold.
   • Flags stale stages and missing next steps.
   • Posts an exception list to #revops.

Across a month, your 5k credits comfortably support:

• Dozens of Jira bugs created automatically from real tickets.
• A couple dozen QBR briefs.
• A few weekly CRM passes on a thin slice of your pipeline.

By the end of the month:

• Support lead says: “These Jira tickets are actually better than what we file.”
• CSMs say: “The QBR briefs save us 20–30 minutes per prep.”
• RevOps says: “The CRM agent catches things we previously missed.”

Now you have proof.

Month 2+: Pro Plan (20k+ credits)

Once the pilots clear the bar, you move to 20k+ Pro and:

1. Expand Support Agent coverage:

   • Broaden from “Top 20 accounts” to all enterprise accounts.
   • Increase triggers from a single Zendesk view to multiple queues.
   • Let the agent handle initial responses in Slack channels for common issues.

2. Standardize Meeting Prep for GTM leaders:

   • Add triggers for director/VP-level recurring meetings.
   • Provide briefs for all QBRs, EBRs, and key renewal calls.
   • Let AEs tag @Gumloop for ad-hoc deal reviews.

3. Scale CRM hygiene org-wide:

   • Run daily workflows for all opportunities over a certain ARR.
   • Add play-specific hygiene rules (renewals, expansions, resellers).
   • Pipe key exceptions into team-specific Slack channels.

Credits-wise, you’re now using Gumloop to:

• Touch hundreds or thousands of tickets, meetings, deals per month.
• Run multiple workflows with 5 concurrent runs so traffic spikes don’t stall your agents.
• Track usage and outcomes via team-level analytics.

At this point, Gumloop isn’t an experiment; it’s part of how support, sales, and CS run.

Pro Tip: When you move from Free to 20k+ Pro credits, don’t just “turn everything on.” Gate expansion behind proof: for each agent, define a success metric (e.g., “80%+ of Jira tickets require zero manual editing”) and only widen coverage once it hits that bar. That’s how you avoid burning credits on noisy workflows.

Summary

5k free credits are designed to answer one question:
“Can Gumloop agents do my real work better/faster than my current manual process?”

Used well, 5k credits will let you:

• Build 2–4 serious agents (Support, CRM, Meeting Prep, Data Analysis, Call Analysis).
• Connect them to real tools (Slack, Zendesk, Jira, Salesforce, your warehouse).
• Run them on a meaningful, but scoped, slice of your workload.

20k+ Pro credits answer a different question:
“Can we rely on Gumloop in production across teams without constantly thinking about limits?”

At that level, you:

• Roll out agents to support, sales, CS, and ops.
• Run workflows more frequently and concurrently.
• Add governance, usage analytics, and shared credit pools.

If you anchor your thinking in work done per month (tickets created, briefs generated, records updated) rather than just “credits,” the Free → Pro path becomes straightforward.

Next Step

Get Started