Skip to main content
Agents are AI-powered assistants that can use tools to solve open-ended tasks. Unlike workflows that follow predetermined paths, agents make intelligent decisions about which tools to use and when, adapting their approach based on the task at hand.

What Are Agents?

Think of agents as intelligent assistants that can orchestrate your workflows. You give them a goal, provide them with tools (integrations and workflows), and they figure out how to accomplish the task by deciding which tools to use and when. Key Characteristics:
  • Adaptive: Different approaches for different situations
  • Tool-driven: Use integrations and workflows as needed
  • Conversational: Interactive back-and-forth discussions
  • Context-aware: Consider your instructions and conversation history
Agents vs. Workflows: Agents are like quarterbacks who read the situation and call the right plays (workflows). Workflows are the plays themselves: reliable, repeatable sequences that execute consistently.

How Agents Work

Agents operate through a framework of Tools, Instructions, and Reasoning.
Agent tools including integrations and workflows

Tools (What Agents Can Use)

Agents are equipped with tools to accomplish tasks:
Direct connections to external services:
  • Gmail: Read, search, and send emails
  • Salesforce: Query records and update data
  • Notion: Search documentation and databases
  • Zendesk: Retrieve and manage support tickets
  • Google Calendar: Check availability and schedule meetings
  • And many more
Agents use the personal default credentials of whoever is running them (unless workspace credentials are configured). You’ll be prompted to authenticate if needed.
Your workflows become powerful tools for agents:
  • Agents see the workflow name and description
  • Understand expected inputs and outputs
  • Call workflows when appropriate
  • Process results to inform next steps
Example: A workflow that queries BigQuery, pulls Salesforce data, and combines them becomes a single “Get User Profile” tool for your agent.
Connect your own MCP server for services not available natively:
  • Internal company APIs
  • Custom data sources
  • Specialized tools
Learn more in the MCP documentation.
Execute code in a secure, isolated environment:
  • Run Python code for data analysis, visualizations, and computations
  • Execute shell commands for file operations and package installation
  • Read/write files in the sandbox filesystem
  • Upload/download files between Gumloop storage and the sandbox
The sandbox comes with 80+ pre-installed Python packages including pandas, numpy, matplotlib, scikit-learn, and more. See the Code Sandbox Tool section below for details.

Instructions (How Agents Behave)

The system prompt defines your agent’s personality, behavior, and decision-making:

Define a Role

Good: “You’re an executive assistant for a CFO of a Fortune 500 company.”Bad: “You help with tasks.”A specific role sets tone, expertise level, and communication style automatically.

Set Tool Usage Rules

Explain when and how to use specific tools:
When the user provides a ticket number:
1. Retrieve ticket details and ask for confirmation
2. Once confirmed, run the "Get User Profile" workflow
3. Read the discount policy from Notion
4. Assess eligibility and explain your reasoning

Establish Confirmation Rules

Define when the agent should ask before acting:“Always ask for confirmation before:
  • Sending emails
  • Deleting data
  • Making changes to external systems”

Specify Response Style

Control tone, length, and format:“Always respond professionally. Keep responses under 100 words. Use bullet points for lists.”
Agent system prompt example

Reasoning (How Agents Think)

When you assign a task, the agent:
  1. Analyzes the request and available tools
  2. Decides which tools to use and in what order
  3. Executes tool calls and adapts based on results
  4. Asks for confirmation when needed (based on instructions)
  5. Explains its reasoning step-by-step
Chat with Agent

Creating Your First Agent

1

Add Tools

Select integrations and workflows your agent needs.Start Simple: Begin with 2-3 tools and add more as needed. Too many tools can overwhelm the agent and make behavior less predictable.
If you’re using workflows as tools, use descriptive names like “Get User Activity and Salesforce Status” instead of “User Workflow” so agents understand when to use them.
2

Write Instructions

Create clear, specific instructions:
You're a support operations assistant helping evaluate discount eligibility.

When given a Zendesk ticket number:
1. Retrieve ticket details and display them
2. Ask for confirmation before proceeding
3. Run "Get User Profile" workflow
4. Read discount criteria from Notion page [URL]
5. Evaluate eligibility with clear reasoning

Always respond professionally. If uncertain, ask for clarification.
Your agent is brilliant but new to your business. Be explicit about your preferences and expectations.
3

Test Thoroughly

Use the built-in chat interface to test:
  • Start Simple: Test basic functionality with straightforward requests
  • Find Edge Cases: Try unexpected inputs and ambiguous requests
  • Refine Instructions: When mistakes occur, ask the agent: “What could I add to your instructions to help you handle this correctly next time?”
  • Document Patterns: Keep notes on successful approaches
Agent builder interface

Embedding Agents in Workflows

Creating an agent is the 0 to 1. Embedding that agent in a workflow is the 1 to 100.
The Agent node lets you run any of your pre-configured agents directly within your workflows. This brings intelligent, adaptive decision-making into your structured automation pipelines and unlocks powerful capabilities.
CapabilityStandalone AgentAgent in Workflow
Manual Chat✅ Yes✅ Yes
Scheduled Runs❌ No✅ Yes
Webhook Triggers❌ No✅ Yes
Event-Based Triggers❌ No✅ Yes
Chain with Other Nodes❌ No✅ Yes
Batch Processing❌ No✅ Yes

Schedule Your Agents

Run agents on a schedule: daily summaries, weekly reports, or any cadence you need.

Trigger via Webhook

Call your agent from external systems using webhook triggers.

Respond to Events

Trigger agents when events happen: new emails, form submissions, database updates.

Chain with Logic

Combine agent intelligence with deterministic workflow logic for hybrid automation.
Learn more about the Agent node in the Agent Node documentation.

Code Sandbox Tool

The Code Sandbox Tool gives your agents the ability to execute code in a secure, isolated environment. This enables agents to perform data analysis, generate visualizations, process files, and run custom scripts.
Adding the Code Sandbox Tool to an agent

What is the Code Sandbox Tool?

The Code Sandbox Tool provides agents with a complete Python execution environment powered by E2B (a secure sandbox platform). When you add this tool to your agent, it gains access to six specialized capabilities that work together to handle complex computational tasks. Unlike traditional code execution that runs on shared infrastructure, the Code Sandbox Tool creates an isolated environment for each conversation. This means your agent can install packages, create files, and run scripts without affecting other users or your production systems.
The sandbox environment persists across tool calls within the same conversation, allowing your agent to build on previous work and maintain state throughout the interaction.

Available Operations

Execute Python code in a secure sandbox environment. This is the primary tool for data analysis, computations, and generating visualizations.Pre-installed packages include: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, and many more.Example uses:
  • Analyze CSV data and compute statistics
  • Generate charts and visualizations
  • Process and transform data
  • Run machine learning models
Execution timeout: 120 seconds per script
Execute shell commands in the sandbox environment. Use this for system operations, package installation, and file management.Actions available:
  • exec: Run a shell command
  • wait: Wait for a background process to complete
  • kill: Terminate a running process
Example uses:
  • Install additional Python packages with pip install
  • Run bash scripts
  • Manage files with cp, mv, rm, mkdir
Perform file operations in the sandbox filesystem.Actions available:
  • view: List directory contents
  • read: Get file content
  • write: Create or overwrite a file
  • append: Add content to an existing file
Search for files and content within the sandbox environment.Actions available:
  • glob: Find files matching a pattern (e.g., *.csv, **/*.py)
  • grep: Search file contents for patterns using regex
Import files from your Gumloop storage into the sandbox for processing.Accepts:
  • gl:// links (e.g., gl://uid-abc/data.csv)
  • Filenames from your Gumloop workspace
Export files from the sandbox back to Gumloop storage and display them in the chat.Files are automatically saved to your Gumloop storage and displayed as attachments in the conversation.
Agent using Code Sandbox Tool to run code and download files
The Code Sandbox environment comes with a comprehensive set of pre-installed Python libraries.Data Science & Analysis: pandas, numpy, scipy, scikit-learn, statsmodelsVisualization: matplotlib, seaborn, plotly, bokehAI & Machine Learning: openai, anthropic, google-generativeai, mistralai, llama-index-core, gensimWeb & APIs: requests, aiohttp, beautifulsoup4, scrapy, selenium, playwrightFile Processing: openpyxl, PyMuPDF, python-docx, Pillow, opencv-python, imageioMedia Processing: moviepy, librosa, ffmpeg-python, yt-dlp, soundfileNatural Language Processing: nltk, spacy, textblobDatabase & Cloud: psycopg2-binary, pymongo, PyMySQL, pyodbc, boto3, google-cloud-storage
If you need a package that isn’t pre-installed, your agent can install it using pip install package-name via the Run Command tool. However, installed packages only persist for the current conversation.
Understanding the limitations helps you design effective agent workflows:
  • Execution Timeouts: Python scripts: 120 seconds max. Shell commands: 60 seconds default. Search operations: 30 seconds.
  • File Size Limits: Individual file: 10MB max. Total workspace: 50MB max.
  • Session Persistence: The sandbox persists within a single conversation. Starting a new conversation creates a fresh sandbox.
  • Network Access: The sandbox has internet access for pip installs and API calls, but cannot access your local network.
  • No GUI Support: The sandbox runs headless. Visualizations must be saved to files (e.g., plt.savefig()).
  • Resource Constraints: Suitable for data analysis and scripting, not for training large ML models.

Example Use Cases

Ask your agent to analyze a dataset:
"Upload my sales_data.csv file and create a summary report with:
- Total revenue by month
- Top 10 products by sales volume
- A bar chart showing monthly trends"
The agent will upload the file, analyze with pandas, generate visualizations with matplotlib, and download the charts.

Be Specific About Outputs

Tell your agent exactly what format you want results in (CSV, chart, summary text) so it knows which tools to use.

Provide Sample Data

When working with data files, describe the structure (column names, data types) to help the agent write correct code.

Using Workflows as Agent Tools

The most powerful pattern is using workflows as tools for agents. This transforms you from manual orchestrator to strategic designer.

Before Agents

You are the orchestrator:
  • Monitor conditions manually
  • Decide when to run workflows
  • String workflows together yourself
  • Handle exceptions and edge cases

With Agents

Agent orchestrates automatically:
  • Monitors and responds to requests
  • Decides which workflows to use
  • Chains workflows intelligently
  • Adapts to results and conditions

Designing Workflows for Agents

When building workflows that agents will use as tools:
Critical: Agents identify workflow parameters through Input and Output nodes.
Input Node: "company_name" (text)
Input Node: "date_range" (text)
[Your workflow logic here]
Output Node: "enriched_data" (object)
Output Node: "success" (boolean)
Without clear inputs/outputs, the agent won’t know how to use the workflow properly.
Workflow names should clearly indicate their purpose:Good: “Get User Activity and Salesforce Status”, “Enrich Lead from LinkedIn Profile”Bad: “User Workflow”, “Flow 1”, “Data Thing”
Write descriptions that help agents understand:
  • What the workflow does
  • When it should be used
  • What inputs it expects
  • What outputs it provides
Example: “Takes a LinkedIn profile URL and returns enriched company data including size, industry, recent funding, and key contacts. Use when researching new leads or companies.”
Each workflow should do one thing well:
  • ✅ “Enrich Contact from Email”
  • ✅ “Send Slack Notification”
  • ❌ “Enrich Contact and Send Notification and Update CRM”
Let the agent orchestrate multiple focused workflows rather than building mega-workflows.

AI Advanced Settings

Fine-tune how your agent’s AI model behaves, manages long conversations, and handles failures. Access these settings by clicking the AI Advanced Settings button in your agent configuration.
AI Advanced Settings panel
Defaults are optimized. All settings are pre-configured for the best balance of performance, cost, and reliability. Only adjust these if you have a specific need.
Customize AI model behavior. Available parameters vary by provider (OpenAI, Anthropic, Google). Settings are stored per-provider, so switching models preserves your preferences for each.
Model configuration options
ParameterRangeDefaultDescription
Reasoning Effortlow, medium, highmediumControls computational effort before responding. Higher = more thorough reasoning but slower and more tokens. Only for o-series and GPT-5 models.
Temperature0–21Controls output randomness. 0 = deterministic, 2 = highly creative.
Max Output Tokens1+AutoUpper bound for generated tokens (includes reasoning tokens). If unset, uses model default.
Max Tool Calls1+AutoLimits total tool calls per response. Useful for cost control.
Top P0–11Nucleus sampling. Model considers only tokens in the top P probability mass. Only for GPT-4o, GPT-4.1, GPT-5.1, GPT-5.2, o3, o4.
Parallel Tool Callson/offonWhen on, model can execute multiple tools simultaneously. Disable if tools depend on each other’s results.
Adjust either Temperature or Top P, not both. Using both produces unpredictable results.
ParameterRangeDefaultDescription
Extended Thinkingenabled, disabledenabledShows Claude’s reasoning process before the final answer. When enabled, temperature is forced to 1.0.
Budget Tokens1,024+10,000Token budget for thinking. Higher = more thorough reasoning but slower. Only shown when thinking is enabled. Must be less than Max Tokens.
Temperature0–11Controls output randomness. Note: forced to 1.0 when Extended Thinking is enabled.
Max Tokens1+AutoMaximum tokens to generate. Defaults: 64,000 (Claude 4.5), 8,192 (older models).
Top P0–11Nucleus sampling threshold.
Top K1+AutoLimits sampling to top K most likely tokens. Lower values (10–40) produce more focused outputs by removing long-tail responses.
Disable Parallel Tool Useon/offoffWhen on, model outputs at most one tool call per response. Enable for strict sequential execution.
ParameterRangeDefaultDescription
Thinking LevelLOW, HIGHHIGHControls depth of internal reasoning. LOW = faster responses, HIGH = deeper analysis. Only for Gemini 2.5 and 3 models.
Temperature0–21Controls output randomness.
Top P0–10.95Nucleus sampling. Note: Google’s default (0.95) is lower than other providers.
Top K1+AutoMaximum tokens considered at each generation step.
Max Output Tokens1+AutoMaximum tokens to generate.
Temperature vs Reasoning: Temperature controls randomness in word selection. Reasoning effort/thinking controls how much the model deliberates before responding. For complex analysis, increase reasoning, not temperature.

Understanding Credit Costs

Agents consume credits based on AI model usage, workflow executions, and integration operations.

How Credits Work

Credits are charged per AI interaction. The cost depends on:
  • Message length: Longer messages consume more credits
  • Model selected: Different AI models have different credit costs
  • Conversation history: Each message includes previous context
  • Tools available: More tools slightly increase base cost

Model Pricing Overview

Best for simple tasks and high-volume usage
Model~Cost per MessageBest For
GPT-4.1 Mini2-3 creditsSimple tasks, quick responses
GPT-5 Mini2-3 creditsGeneral queries
Claude Haiku 4.52-4 creditsFast interactions
Note: Credit costs shown are approximate per message. Actual costs vary based on message length, conversation history, number of tools available, and whether the agent executes workflows during the interaction.
Message Length: Longer inputs and outputs consume more tokens. Short message (~50 words): ~500 tokens. Medium (~200 words): ~2,000 tokens. Long (~500 words): ~5,000 tokens.Conversation History: Each message includes previous context. 1st message: Base cost. 5th message: ~20% higher. 10th message: ~40% higher. Start new conversations for unrelated topics.Tool Availability: More tools = larger system prompt. 2-3 tools: Base cost. 5-10 tools: +10-20%. 15+ tools: +30-40%.Multi-Step Operations: Workflow calls trigger multiple AI steps. Example: Decide to call workflow (~5 credits) + Process results (~5 credits) + Generate response (~5 credits) = ~15 credits + workflow cost.

Workflow and Integration Costs

When agents call workflows or integrations, additional costs apply:
Node TypeCredit CostExamples
Free Nodes0 creditsInput/Output, Filter, Router, Most integrations
Low Cost2-3 creditsAsk AI (simple), Run Code, Custom Operators
Medium Cost10-30 creditsAI with large prompts, AI Vision
High Cost10-60+ creditsData enrichment, Premium APIs
Integration Costs:
  • Free: Google Workspace, Slack, Airtable, Notion, Salesforce, HubSpot, 150+ more
  • Paid: Data enrichment services (eg. Hunter.io ~10 credits, ZoomInfo ~60 credits)

Optimizing Credit Usage

Choose Appropriate Models

Use budget models for simple tasks. Reserve expert models for complex analysis that truly requires advanced reasoning.

Keep Conversations Focused

Start new conversations for different topics. Long threads accumulate context costs with each message.

Write Clear Prompts

Specific prompts get better results faster, reducing back-and-forth messages and total credit consumption.

Limit Tool Count

Start with 2-3 essential tools. Each additional tool increases the system prompt size and base cost.

Tracking Credit Usage

Monitor your credit consumption across multiple views:
Agent credit cost
  • Real-time Display: Credits shown next to each agent response as it streams
  • Conversation History: View total credits per conversation thread
  • History Page: See credit costs for agent chats and Agent node executions (when run via workflows)
  • Account Dashboard: Track total credits used across all agents and timeframes

Credentials & Authentication

How Agents Use Credentials

When an agent uses integrations and workflows, it needs credentials to access external services. Understanding how credentials work is essential for secure and effective agent deployment.
Key principle: Agents always use the credentials of the person running the agent, not the agent creator’s credentials. If you run the agent, it uses your credentials. If a teammate runs it, it uses their credentials.
Workspace agents are created in shared workspaces and have two key differences from personal agents:1. Access Control: Only members of the workspace can use the agent. Non-members will receive an “access denied” message.2. Credential Behavior: If an MCP integration or workflow is set to use “workspace default” credentials, those workspace credentials are used instead of personal credentials. Otherwise, the personal default credentials of whoever is running the agent are used.Best for: Team collaboration requiring shared credentials, controlled access to specific workspace membersLearn more about workspaces in the Organizations and Workspaces documentation.
Before using an agent with integrations:
  1. Visit your credentials page
  2. Authenticate with required services (Gmail, Salesforce, etc.)
  3. Set credentials as your personal default
What happens if credentials are missing:
  • The agent will notify you about missing authentication
  • You’ll receive a link to the credentials page
  • After authenticating, return and retry your request
Agents will automatically detect missing credentials and guide you through the authentication process.

Data Privacy & Security

Your Data Stays Private

With personal agents and personal credentials, only your authenticated accounts are accessed. Other users cannot see your data through the agent.

Controlled Access

Admin security controls and user roles apply to agents just like workflows. You can only access what you’re authorized to access.

Best Practices

Begin with 2-3 tools and straightforward instructions. Test thoroughly before adding more capabilities.Anti-pattern: Creating an agent with 15 tools and a 2000-word system prompt immediately.Better approach: Start with core functionality, observe how the agent behaves, then incrementally add tools and refine instructions based on real usage.
Agents improve over time as you refine instructions based on real interactions:
  • Review conversation history regularly for patterns
  • When agents make mistakes, ask: “What could I add to your instructions to prevent this?”
  • Document edge cases and add explicit handling rules
  • Celebrate successful patterns and codify them in instructions
When creating workflows that agents will call:
  • Always use Input and Output nodes so agents understand parameters
  • Keep workflows focused on single responsibilities
  • Use descriptive names that indicate purpose
  • Write clear descriptions explaining when to use the workflow
  • Test workflows independently before giving them to agents
Define what agents should NOT do to prevent unintended actions:
Never:
- Delete customer data or records
- Send emails without explicit user approval
- Make purchases or financial commitments
- Override manual decisions by team members
- Modify production data without confirmation
Be explicit about destructive actions requiring human oversight.
Track metrics to understand agent effectiveness:
  • Time saved: Hours saved per week through automation
  • Success rate: Tasks completed successfully vs requiring intervention
  • Tool usage: Which workflows/integrations are used most frequently
  • Credit efficiency: Cost per completed task or interaction

Troubleshooting

Symptoms: Agent calls inappropriate tools or skips necessary stepsSolutions:
  • Make tool names more descriptive and explicit
  • Add specific “When to use” guidance in system prompt
  • Reduce number of similar tools that might confuse the agent
  • Provide examples: “When user asks X, use tool Y”
  • Check if workflow descriptions clearly explain their purpose
Symptoms: Agent fails to call workflows correctly or misinterprets resultsSolutions:
  • Ensure workflows have Input and Output nodes defined
  • Use clear, descriptive names for input/output fields
  • Add workflow descriptions explaining parameters
  • Test workflow independently to verify inputs/outputs work
  • Simplify complex workflows into smaller, focused ones
Symptoms: Agent reports missing credentials or authentication failuresSolutions:
  • Visit your credentials page
  • Authenticate with the required service
  • Set it as your personal default credential
  • For workspace agents using workspace credentials, contact your workspace admin
  • Return to the agent and retry your request
Symptoms: Agent seeks approval for routine operations, slowing down interactionsSolutions:
  • Explicitly list operations that don’t need confirmation
  • Add “proceed automatically when…” clauses for common scenarios
  • Specify conditions under which confirmation IS required
  • Review and tighten confirmation rules in system prompt
Symptoms: Agent takes sensitive actions without required approvalSolutions:
  • Add explicit “always ask before…” rules for destructive actions
  • List all sensitive operations requiring human approval
  • Include examples of when to ask vs when to proceed
  • Test with dry-run scenarios before giving real access
Symptoms: Responses too verbose, too terse, wrong tone, or poor formattingSolutions:
  • Update role definition to set appropriate tone
  • Add response format examples in instructions
  • Specify length constraints: “Keep responses under 100 words”
  • Request specific formatting: “Use bullet points for lists”
  • Provide example responses that match desired style
Symptoms: Agent stops mid-task, declares tasks impossible, or gets stuckSolutions:
  • Verify all required tools are properly connected
  • Check authentication for all integrations (agents will prompt if needed)
  • Review error logs in conversation history for specific failures
  • Simplify initial instructions and build up complexity gradually
  • Test individual tools work before expecting agent to orchestrate them
  • Check if workflows have errors that prevent agent from calling them
Symptoms: Agent consuming more credits than expectedSolutions:
  • Switch to a less expensive model for simple tasks
  • Start new conversations instead of continuing long threads
  • Reduce number of tools to decrease system prompt size
  • Optimize workflows to use fewer AI nodes
  • Write clearer prompts to reduce back-and-forth messages
  • Review if agent is making unnecessary tool calls

Next Steps