AI agent ops stack — always-on agents without engineering

The stack a lean ops team runs when it wants agents that fire on events instead of a chat window somebody has to remember to open. Gumloop builds and hosts the agents, n8n moves work between systems and enforces the approval gate, Clay supplies the outside data an agent needs before it can decide anything, and Slack is where a human says yes or no. Four tools, roughly $1.1K-$11K a year, no engineer on the org chart.

The distinction that decides whether you need this at all: it is not a stack for automating known, fixed steps. If the steps never change — copy field A to field B when a form fires — n8n alone does that cheaper and more reliably. This stack earns its cost when the input is unstructured and the decision needs judgment applied case by case: an inbound email that may or may not be a real demand, a CV against a scorecard, an NDA with a non-standard indemnity clause, a support thread that might be a churn signal.

How the pieces fit

• Gumloop is the agent layer. Since its 2026 repositioning it leads with agents and keeps the visual canvas underneath: agents run in chat, in Slack, from an agent email inbox, or on schedule and event triggers, and call a canvas workflow when a step should be repeatable rather than reasoned. Model choice is per node across 35+ models, so one agent can call Claude for clause extraction and a cheaper model for classification in the same run. Its retrieval surface, Brain, indexes Notion, Google Drive, Slack, GitHub, Confluence, Zendesk and Salesforce, and for Drive and Salesforce it inherits source permissions — an agent returns only what the asking user could already open. Gumloop is not your system of record: it reads, reasons, and emits.

• n8n is the orchestration and guardrail layer. Every handoff between Gumloop and the rest of your SaaS is an n8n workflow: it receives the agent’s output, checks it against thresholds you set, decides whether the action can execute unattended or needs a human, writes to the system of record, and catches the failures. It is also where the audit trail lives — n8n’s execution log is the record of what an agent did and why, which matters the first time someone asks.

• Clay is the outside-data layer. An agent reasoning about an inbound lead, a candidate, or a counterparty needs facts the trigger event does not contain: headcount, funding, tech stack, whether this domain is already a customer. Clay waterfalls each lookup across its provider marketplace and, since the March 2026 metering change, charges only on a hit. Without it, agents make confident decisions on the strength of an email signature.

• Slack is the approval and audit surface. Any agent action above the authority threshold posts to a channel as an approve/reject message before it executes. This is the component teams skip, and skipping it is why unattended agent projects get switched off in month two — nobody could see what the thing was doing.

Named handoffs

1. Event → triage. An email lands in a shared inbox, a form is submitted, or a file drops in a folder → Gumloop agent extracts the entities, classifies the request, and emits structured JSON with a confidence value.
2. Unknown entity → enrichment. Gumloop’s output names a company or person not already in your CRM → n8n triggers the Clay table run → enriched row returns to the agent’s context before it recommends an action.
3. Recommendation → gate. Gumloop returns a recommended action → n8n evaluates it against the threshold (confidence above the bar and value below the cap executes unattended; anything else routes to Slack as an approval card with the agent’s stated reasoning attached).
4. Approval → write. A human clicks approve in Slack → n8n writes to the system of record (CRM, ATS, or CLM) and posts the receipt back into the same thread, so the decision and its consequence sit in one place.
5. Failure → owner. An agent run errors, a Clay lookup returns nothing, or monthly credit consumption crosses a ceiling → n8n’s error workflow alerts the named ops owner in Slack rather than failing silently.

Why this combination

Each tool sits in one layer and the layers do not overlap: Gumloop reasons, Clay supplies facts, n8n routes and gates, Slack holds the human. That separation is what makes the stack debuggable by a non-engineer — when something goes wrong there is exactly one place it went wrong.

Two collapses are worth naming, because both are sometimes right. n8n alone can do everything Gumloop does; its AI Agent node connects any model to tools and memory, and self-hosted it is free. What you pay instead is build hours and the requirement that somebody can debug a failed webhook at 6pm. Gumloop alone can call APIs directly and skip n8n. What you lose is the gate — approval logic, thresholds, retries, and error routing scatter inside individual agents instead of sitting in one enforced layer, which is fine for two agents and unmanageable at ten.

Gumloop is the default agent layer here rather than a per-seat assistant product because its plan includes unlimited seats and bills on pooled credits: letting the whole ops team build against the same agents costs nothing extra, and a shared queue is what this stack exists to serve.

Cost reality

Annual bands for a 3-10 person ops team, from vendor pricing pages checked 2026-09-06:

• Gumloop: ~$450-$3,000/year. Pro is $37/month with 20,000 credits, unlimited seats, 5 concurrent workflow runs, 25 concurrent agent chats, and one hosted MCP server; the credit slider scales to 1.5M/month. There is no free plan — it was withdrawn on 2026-07-30 in favor of a 14-day Pro trial. Enterprise (request queueing, RBAC, SCIM/SAML, audit logs, VPC, custom MCP hosting) is quote-only.
• n8n: ~$0-$800/year. The self-hosted Community Edition is free; budget $20-40/month for a VPS. On cloud, Starter is €20/month billed annually for 2,500 executions and Pro is €50/month for 10,000. Billing is per workflow execution regardless of step count, and users are unlimited on every plan. Business, at €667/month billed annually, adds 40,000 executions and self-hosted deployment; under 20 employees it is 50% off through n8n’s startup plan, which is the one discount in this stack a team of this size actually qualifies for.
• Clay: ~$0-$5,400/year. A free plan returned with 100 data credits and 500 actions a month — enough to pilot, not enough to run. Launch is $185/month ($167 billed annually) for 3,000 data credits and 15,000 actions; Growth is $495/month ($446 billed annually) for 6,000 and 40,000. Billing runs on two meters — data credits for provider lookups, actions for AI runs and integrations — so an agent stack that calls Clay on every trigger burns both.
• Slack: ~$450-$1,800/year. Pro is $7.25/user/month billed annually ($8.75 monthly); Business+ is $15/user/month billed annually. Only the people who approve things need a paid seat.

Total: ~$1.1K-$11K/year. The floor moved down since this page last priced the stack, because Clay reintroduced a free tier and n8n self-hosting is still free: a genuine pilot now costs a Gumloop subscription and five Slack seats. The ceiling is where a production stack lands once Clay is metering real volume.

Budget Gumloop against its credit line, not its $37. Credits meter at 1 credit = $0.005, and an agent chat bills on five components: chat and reasoning tokens, a minimum of 1 credit per successful tool call, compute at 5 credits per session-minute, an 8% orchestration fee on those three, and the full cost of any workflow the agent triggers. Compute alone puts a 60-minute agent session at 300 credits before a token is counted. Canvas workflows cost far less — 1 credit to start plus per-node cost, most native nodes free, no compute or orchestration charge — which is the concrete reason to push deterministic stretches out of the agent and into a workflow it calls.

The other hidden costs are the usual ones: 2-4 weeks of an ops person’s time to get the first three agents to a state you would leave unattended, ongoing credit drift as agents get chattier, and the maintenance tax of a Gumloop canvas that grows past about 30 nodes and stops being readable.

What this stack does not replace

• Your system of record. Nothing here stores customer, candidate, or contract state. The agents act on your CRM, ATS, or CLM; they do not become one.
• Engineering, for anything transactional. Money movement, provisioning, anything needing a real transaction boundary or an uptime commitment belongs in code with tests, not on a hosted canvas.
• A data warehouse. Clay enriches records in flight. Historical analysis, attribution, and reporting still need somewhere to land.
• Accountability for the decision. The approval gate does not transfer responsibility to the agent. Whoever clicked approve owns the outcome, which is exactly why the reasoning has to be in the Slack message and not buried in a run log.

Match rules

Use this stack when:

• Your highest-volume ops work starts as unstructured text — inboxes, applications, tickets, contracts — and someone is currently reading all of it.
• You have an ops person who is comfortable on a visual canvas and can read JSON, but you do not have and will not get engineering time.
• Volume is high enough that per-item human triage is a real cost (roughly 100+ items a month) but low enough that an error is recoverable rather than a compliance event.
• You can name the threshold. If you cannot say what an agent is allowed to do unattended, you are not ready to run one unattended.

Do not use this stack when:

• The steps are fixed and known. Use n8n on its own and put the savings somewhere else.
• The decision is regulated — adverse action on a candidate, a legal position, anything with a statutory notice attached. Agents can draft and route; a human decides, and the audit trail has to show it.
• Nobody owns it. An agent stack with no named owner degrades quietly: credits climb, an integration’s auth expires, and the failure surfaces as a customer complaint months later.
• You are still figuring out what the process is. Agents operationalize a decision rule; they do not discover one. Write it down manually for a month first.

Watch-outs

• Slack is now readable by agents, not just by people. Slack’s remote MCP server reached GA on 2026-02-17 at mcp.slack.com, using user-token OAuth behind a workspace-admin approval flow, so an approved client reads and posts within the authenticating user’s own permissions. The approval channel is no longer a surface only humans see. Guard: keep approvals in a dedicated channel whose membership you can name, and approve MCP clients at the workspace-admin level rather than letting individuals connect their own.
• Bringing your own model key raises Gumloop’s platform fee rather than lowering it. BYOK drops reasoning tokens from your credit balance but moves orchestration from 8% to 16% of chat, compute, and tool-call credits. Guard: run the same flow both ways over a 10-row test set and read the credit dashboard first — BYOK wins only when your negotiated model rate beats the pass-through by more than the extra 8%.
• Gumloop Pro rejects excess concurrency instead of queueing it. Past 5 concurrent workflow runs the API returns HTTP 429 and agent chats fail; queueing is an Enterprise feature, so a 500-row batch fired as parallel runs drops work silently if nothing retries. Guard: stagger triggers from n8n, split large jobs into subflows, and build retry-on-429 into anything calling the API.
• Clay’s free tier is a pilot budget, not a production one. 100 data credits a month covers roughly a day of real triage. Guard: measure the enrichment step’s hit rate during the pilot and size Launch or Growth from that, rather than finding the ceiling when agents start deciding on missing data.

Common variations

• Swap Gumloop for Lindy when the job is one person’s inbox, not a team’s queue. Lindy prices per user — Plus at $29.99/month for 3,000 credits, Pro at $99.99 for 15,000, Max at $199.99 for 35,000 — with up to 5 connected inboxes and computer use on every plan, and credits pooled across the workspace. The rule: one executive’s email, calendar, and follow-ups → Lindy; a shared queue several people build against → Gumloop, whose seats are unlimited.
• Drop Clay when the agents only touch data you already own. Support ticket triage, contract review, and internal-document work need no external enrichment, and Clay is the largest removable line in the stack. Add it back the day an agent starts making decisions about companies or people that are not yet in your CRM.
• Collapse to n8n alone when you gain a builder. If a technical hire lands, the AI Agent node absorbs the Gumloop layer and the recurring cost drops to a VPS. This is a real downgrade in who can maintain it — do it when the person is on the team, not when they are on the hiring plan.
• Swap Slack for Microsoft Teams. The approval surface is the same shape and n8n has a first-class Teams node. What you give up is the Slack MCP path above, so agent-side reading of the approval thread goes back to being a custom integration.

For the concrete agent patterns this stack runs, see inbound lead triage, NDA intake triage, and lead enrichment with Clay and Claude. For the underlying concept, AI agents for ops covers what separates an agent from a scheduled script.