Agent Task Automation: The Best of Both Worlds

The Run Agent Task automation action represents a breakthrough in workflow design: the ability to seamlessly transition between structured, deterministic automation steps and intelligent, autonomous agent actions. This bridges two previously separate paradigms, giving you the reliability of automation combined with the adaptability of AI.

New to Automations? Check out the Automation System guide first to understand how event-driven workflows work in Elementum.

The Core Concept

Traditional automation excels at structured, deterministic processes: “When X happens, do Y.” AI agents excel at unstructured tasks requiring reasoning, judgment, and proactive problem-solving. Until now, these have been separate capabilities. Run Agent Task changes this. You can now build workflows that:

Start with structured automation (trigger detection, data gathering)
Hand off to an autonomous agent (intelligent analysis, research, decision-making)
Return to structured automation (use agent output in subsequent actions)

Record Updated (structured) → 
  Run Agent Task (autonomous intelligence) → 
  Update Record Fields (structured) → 
  Send Email Notification (structured)

This pattern unlocks entirely new categories of workflows that were previously impossible or impractical.

Why This Matters

The Limitations Before Run Agent Task

Pure Automation Approach:

Excellent at deterministic tasks
Struggles with tasks requiring judgment
Can’t handle “figure it out” scenarios
Limited to predefined logic paths

Pure Agent Approach:

Excellent at complex reasoning
Can handle ambiguous tasks
Unreliable for deterministic steps
Harder to integrate into existing processes

The Hybrid Approach

Run Agent Task gives you both:

Structured Reliability

Use automation for data gathering, record updates, notifications, and integrations

Intelligent Autonomy

Use agents for research, analysis, evaluation, and tasks requiring reasoning

Real-World Example: Consider customer order processing: Before: Either use rigid automation rules (fast but inflexible) or manual review (flexible but slow) With Run Agent Task:

Order Received (structured) →
  Search Records: Get customer history (structured) →
  Run Agent Task: "Analyze this order from {{customer.name}} for {{product.name}}. 
    Based on their history of {{customer.past_orders}}, identify any risks, 
    upsell opportunities, or special handling needs. Success: Provide actionable 
    recommendations for the fulfillment team." (autonomous intelligence) →
  Update Record Fields: Add agent insights (structured) →
  IF agent_task.requires_special_handling = true →
    Make Assignment: Route to senior fulfillment (structured) →
  Send Email: Confirmation with personalized recommendations (structured)

This workflow uses automation for speed and reliability while leveraging agent intelligence where judgment matters.

Understanding the Run Agent Task Action

Configuration Components

1. Action Name

Descriptive name for the task within your automation workflow.

"Research Customer Industry"
"Evaluate Contract Risk"
"Analyze Support Ticket Complexity"

2. Agent Selection

Choose an existing agent or create a new one specifically for this task. Agent Design Considerations:

Specialized agents: Create agents with expertise domains (research, analysis, evaluation)
General agents: Use broad-capability agents for varied tasks
Consistent agents: Reuse the same agent across similar automation tasks for consistency

3. Task Definition

The heart of the action. This is where you tell the agent what to accomplish. Critical Components: Context - Provide all necessary information using value references:

"Analyze the support ticket from {{customer.name}} regarding {{ticket.subject}}.
Customer tier: {{customer.tier}}
Previous tickets: {{customer.past_tickets}}
Product: {{ticket.product}}"

Objective - What the agent should accomplish:

"Determine the complexity of this issue and recommend whether it needs specialist 
escalation or can be handled by general support."

Success Criteria - How the agent knows it has completed the task:

"Success: Provide a complexity rating (Low/Medium/High), estimated resolution time, 
recommended assignment team, and specific reasoning for the recommendation."

Complete Example:

Task: "Analyze the support ticket from {{customer.name}} regarding {{ticket.subject}}.
Customer tier: {{customer.tier}}, previous tickets: {{customer.past_tickets}}.

Objective: Determine issue complexity and routing.

Success: Provide:
- Complexity rating (Low/Medium/High)
- Estimated resolution time in hours
- Recommended team (General/Specialist/Engineering)
- 2-3 sentence reasoning for recommendations"

4. Output Type

Choose how the agent returns its work: Text Output:

Simple narrative response
Good for summaries, explanations, recommendations
Flexible format

Structured Output:

Define specific fields you want returned
Works exactly like AI File Reader
Ensures consistent data format
Enables direct use in subsequent actions

Structured Output Example: Fields you define:

complexity_rating (text): Low/Medium/High
estimated_hours (number): Resolution time estimate
recommended_team (text): Team name
reasoning (text): Explanation of recommendations
requires_escalation (checkbox): Boolean flag

The agent will return data in exactly this structure, making it easy to use in subsequent automation steps.

5. Testing & Preview

Before deploying, test your agent task with real values:

Fill in value references with actual data
Run the agent task
Verify the output format and quality
Adjust task definition if needed

Best Practice: Test with multiple scenarios (simple cases, complex cases, edge cases) to ensure consistent agent performance.

When to Use Run Agent Task

Ideal Use Cases

Research & Analysis

Scenario: Tasks requiring information gathering and synthesisExample:

New Lead Created → Run Agent Task
Task: "Research {{lead.company}} to identify:
- Industry and market position
- Recent news or developments
- Competitive landscape
- 3-5 key talking points for our sales team
Success: Provide actionable sales intelligence"
Output Type: Structured
Fields: industry, company_size, recent_news, talking_points, research_confidence

Why Agent Task: Research requires judgment about what information is relevant and how to synthesize it meaningfully.

Complex Evaluation & Assessment

Scenario: Decisions requiring multiple factors and reasoningExample:

Contract Uploaded → AI File Analysis → Run Agent Task
Task: "Evaluate this contract with terms {{contract.terms}} and value {{contract.value}}.
Consider our standard terms, risk tolerance, and relationship with {{customer.name}}.
Success: Provide risk assessment (Low/Medium/High), key concerns, and approval recommendation."
Output Type: Structured
Fields: risk_level, key_concerns, approval_recommended, negotiation_points

Why Agent Task: Contract evaluation requires understanding context, comparing terms, and making nuanced risk assessments.

Content Quality Assessment

Scenario: Evaluating quality, completeness, or appropriateness of contentExample:

Application Submitted → Run Agent Task
Task: "Review this grant application from {{applicant.name}} for {{project.title}}.
Application content: {{application.content}}
Grant criteria: {{grant.criteria}}
Success: Evaluate completeness, alignment with criteria, and provide score (1-10) with feedback."
Output Type: Structured
Fields: completeness_score, criteria_alignment, overall_score, strengths, improvements_needed

Why Agent Task: Quality assessment requires judgment and understanding of nuanced criteria.

Intelligent Data Enrichment

Scenario: Enhancing records with synthesized informationExample:

Customer Record Created → Run Agent Task
Task: "Enrich data for {{customer.company}} in {{customer.industry}}.
Success: Provide company size estimate, key decision makers' typical titles, 
common pain points in their industry, and recommended product fit."
Output Type: Structured
Fields: company_size_estimate, decision_maker_titles, industry_pain_points, product_recommendations

Why Agent Task: Data enrichment requires synthesis of multiple sources and intelligent inference.

Multi-Step Problem Solving

Scenario: Tasks requiring sequential reasoning and proactive actionExample:

Complex Issue Detected → Run Agent Task
Task: "Diagnose this system issue: {{issue.description}}
Recent changes: {{system.recent_changes}}
Error logs: {{system.errors}}
Success: Provide root cause analysis, step-by-step resolution plan, and prevention recommendations."
Output Type: Structured
Fields: root_cause, resolution_steps, estimated_fix_time, prevention_measures

Why Agent Task: Problem diagnosis requires connecting information, reasoning about causes, and planning solutions.

When NOT to Use Run Agent Task

Use standard automation actions instead when:

Deterministic Logic

Simple IF/THEN logic, calculations, or predefined rulesUse: IF conditions, Run Calculation

Direct Data Operations

Creating, updating, searching, or relating records with known valuesUse: Create Record, Update Record Fields, Search Records

Standard Classifications

Categorization with clear, predefined categoriesUse: AI Classification

API Integrations

Direct calls to external systems with structured parametersUse: Send API Request

Decision Framework: Ask yourself: “Does this task require reasoning, judgment, or synthesis of information to determine what to do?”

Yes → Consider Run Agent Task
No → Use standard automation actions

The Headless Environment

A critical concept: agents in Run Agent Task operate in a headless environment - there is no user available to provide clarification or additional input.

What This Means

No User Interaction:

Agent cannot ask follow-up questions
Agent cannot request additional information
Agent cannot seek clarification

Must Be Self-Contained:

All context provided upfront through value references
Task definition must be complete and clear
Success criteria must be unambiguous

Best Practices for Headless Operation

1. Provide Complete Context

Bad:

Task: "Research this customer"

Good:

Task: "Research {{customer.company}} (industry: {{customer.industry}}, 
size: {{customer.employees}} employees, location: {{customer.location}}).
Focus on their competitive landscape, recent news, and decision-making structure.
Use our product category ({{product.category}}) to identify relevant talking points."

2. Define Clear Success Criteria

Bad:

Task: "Analyze this contract and let me know what you think"

Good:

Task: "Analyze this contract for {{customer.name}}.
Success criteria: 
- Identify any terms that deviate from our standard template
- Rate overall risk as Low/Medium/High
- Flag any must-negotiate items
- Provide recommended approval authority based on risk and value"

3. Use Value References Extensively

Make all relevant data available:

Task: "Evaluate support ticket #{{ticket.id}} from {{customer.name}}.
Customer details:
- Tier: {{customer.tier}}
- Account age: {{customer.age_days}} days
- Lifetime value: ${{customer.lifetime_value}}
- Previous tickets: {{customer.ticket_count}}
- Recent issues: {{customer.recent_issues}}

Ticket details:
- Subject: {{ticket.subject}}
- Description: {{ticket.description}}
- Reported by: {{ticket.reporter_name}} ({{ticket.reporter_role}})

Success: Determine urgency (Critical/High/Medium/Low), estimated effort 
(hours), recommended team, and whether customer success should be notified."

4. Anticipate Agent Needs

Think through what information an intelligent human would need:

Historical context
Business rules or policies
Comparative data
Success thresholds
Constraints or limitations

Working with Structured Output

Structured output is powerful because it ensures consistent, usable data from agent tasks.

Defining Output Fields

Similar to AI File Reader, you define exactly what fields you want: Field Configuration:

Field Name: Variable name for use in subsequent actions
Field Type: text, number, checkbox, date, list, etc.
Description (optional but recommended): Helps the agent understand what you want

Example Configuration:

Output Type: Structured

Fields:
risk_score (number): Overall risk rating from 1-10
risk_level (text): Low/Medium/High categorization
key_risks (list): Specific risk factors identified
mitigation_required (checkbox): Whether mitigation actions are needed
mitigation_steps (text): Recommended mitigation actions if needed
approval_recommended (checkbox): Whether to recommend approval
reasoning (text): 2-3 sentence explanation of assessment

Using Output in Subsequent Actions

Once the agent task completes, its output becomes available as variables:

run_agent_task.success = true
run_agent_task.error_message = ""
run_agent_task.risk_score = 7
run_agent_task.risk_level = "Medium"
run_agent_task.key_risks = ["Payment terms exceed standard", "Unusual termination clause"]
run_agent_task.mitigation_required = true
run_agent_task.approval_recommended = true
run_agent_task.reasoning = "Contract presents moderate risk but relationship value justifies approval with mitigation."

In Subsequent Actions:

IF run_agent_task.risk_level = "High" OR run_agent_task.mitigation_required = true
  → Start Approval Process (Legal team)
  → Send Message to Teams: "High-risk contract requires review: {{run_agent_task.reasoning}}"
OTHERWISE
  → Update Record Fields (auto-approved)
  → Send Email Notification: "Contract approved: {{run_agent_task.reasoning}}"

Error Handling with Structured Output

The system includes built-in retry logic (up to 3 attempts) when agents don’t provide correctly formatted output:

Agent attempts to provide structured output
If format is incorrect, system returns error to agent with details
Agent tries again with error context
Repeat up to 3 times

Your Error Handling: Always check the success field:

Run Agent Task → IF run_agent_task.success = true
  → Process normally
OTHERWISE
  → Handle error:
    - Log error: {{run_agent_task.error_message}}
    - Send notification to admin
    - Route to manual review

Real-World Workflow Examples

Example 1: Intelligent Order Processing

Scenario: E-commerce company wants to provide personalized order handling

Order Created
  ↓
Search Records: Get customer history
  ↓
Run Agent Task: "Analyze Order Personalization"
  Task: "Analyze order from {{customer.name}} for {{order.items}}.
    Customer history: {{customer.past_orders}}, lifetime value: ${{customer.ltv}},
    preferences: {{customer.preferences}}.
    Success: Identify upsell opportunities, special handling needs, personalized 
    message suggestions, and estimated satisfaction impact of personalization."
  Output Type: Structured
  Fields: upsell_items (list), special_handling (text), personalized_message (text),
          satisfaction_impact (text), include_sample (checkbox)
  ↓
IF run_agent_task.include_sample = true
  → Update Record Fields: Add free sample to order
  ↓
IF run_agent_task.upsell_items has values
  → Send Email: Order confirmation with personalized recommendations
  → Body: "Thank you for your order! {{run_agent_task.personalized_message}}
          Based on your interests, you might also like: {{run_agent_task.upsell_items}}"
OTHERWISE
  → Send Email: Standard confirmation
  ↓
Create Record: Log personalization actions for future learning

Why This Works:

Structured steps for order retrieval and customer lookup
Agent intelligence for personalization analysis
Structured steps for order updates and communications
Combines speed of automation with quality of human-like judgment

Example 2: Smart Support Ticket Routing

Scenario: Support organization wants intelligent ticket routing beyond simple keywords

Support Email Received
  ↓
AI Classification: Categorize ticket type
  ↓
Search Records: Find customer
  ↓
Find Related Records: Get customer's recent tickets and products
  ↓
Run Agent Task: "Intelligent Ticket Assessment"
  Task: "Assess support ticket from {{customer.name}} about {{ticket.subject}}.
    Ticket content: {{ticket.body}}
    Customer tier: {{customer.tier}}
    Recent tickets: {{related_tickets.summaries}}
    Customer products: {{customer.products}}
    Success: Determine complexity (1-5), required expertise (General/Product/Engineering),
    urgency (Low/Medium/High/Critical), and whether this is part of a pattern."
  Output Type: Structured
  Fields: complexity_score (number), required_expertise (text), urgency (text),
          pattern_detected (checkbox), pattern_description (text), 
          estimated_resolution_hours (number)
  ↓
IF run_agent_task.pattern_detected = true
  → Add Watcher: Customer Success Manager
  → Post Comment: "Pattern detected: {{run_agent_task.pattern_description}}"
  ↓
IF run_agent_task.urgency = "Critical"
  → Make Assignment: Senior Support (immediate)
  → Send Message to Teams: "@support-leads Critical ticket: {{ticket.subject}}"
ELSE IF run_agent_task.required_expertise = "Engineering"
  → Make Assignment: Engineering Team
  → Start Approval Process: Engineering time allocation
OTHERWISE
  → Make Assignment: General Support
  ↓
Update Record Fields:
  - Complexity: {{run_agent_task.complexity_score}}
  - Estimated Hours: {{run_agent_task.estimated_resolution_hours}}
  - Urgency: {{run_agent_task.urgency}}
  ↓
Send Email Notification: Customer confirmation with estimated timeline

Why This Works:

AI Classification handles basic categorization
Agent Task handles nuanced assessment requiring context and judgment
Structured routing logic uses agent insights
Pattern detection enables proactive customer success intervention

Example 3: Intelligent Document Review

Scenario: Legal team needs automated first-pass contract review

Contract Attachment Added
  ↓
AI File Analysis: Extract contract data
  ↓
Search Records: Find customer and relationship history
  ↓
Run Agent Task: "Contract Risk Assessment"
  Task: "Review contract from {{customer.name}} with value {{contract.value}}.
    Extracted terms: {{ai_file_analysis.terms}}
    Standard terms: {{company.standard_contract_terms}}
    Customer relationship: {{customer.relationship_years}} years, 
                          LTV: ${{customer.lifetime_value}}
    Success: Assess risk (Low/Medium/High), identify deviations from standard,
    flag must-negotiate items, and recommend approval authority."
  Output Type: Structured
  Fields: risk_level (text), deviations (list), must_negotiate (list),
          recommended_approver (text), business_justification (text),
          expedite_recommended (checkbox)
  ↓
Update Record Fields: Add risk assessment and recommendations
  ↓
Post Comment: "AI Contract Review:
  Risk: {{run_agent_task.risk_level}}
  Deviations: {{run_agent_task.deviations}}
  Recommendation: {{run_agent_task.business_justification}}"
  ↓
IF run_agent_task.risk_level = "High"
  → Start Approval Process: Legal + CFO
  → Send Message to Teams: "#legal High-risk contract requires review"
  ↓
ELSE IF run_agent_task.risk_level = "Medium"
  → IF run_agent_task.expedite_recommended = true
      Start Approval Process: Legal only (expedited)
  → OTHERWISE
      Start Approval Process: Legal only (standard)
  ↓
OTHERWISE (Low risk)
  → IF contract.value < $10000
      Update Record Fields: Auto-approved
      Send Email: Approval confirmation
  → OTHERWISE
      Start Approval Process: Manager only
  ↓
Save Attachment: Link contract to customer record

Why This Works:

AI File Analysis extracts data (structured)
Agent Task provides nuanced risk assessment (intelligence)
Routing logic uses risk assessment (structured)
Combines speed of automation with quality of expert review

Best Practices

Task Definition Quality

Be Specific but Not Restrictive

Goal: Give the agent clear direction while allowing intelligent interpretationBad:

"Look at this customer and tell me stuff"

Good:

"Analyze {{customer.company}} in the {{customer.industry}} industry. 
Focus on: competitive position, growth trajectory, and alignment with our 
target customer profile. Success: Provide actionable insights for our sales approach."

Why: Specific objectives with room for intelligent interpretation gives best results.

Include Success Evaluation Criteria

Goal: Help the agent understand what “done” looks likePattern:

Task: [Context and objective]
Success: [Specific deliverables and quality criteria]

Example:

Task: "Evaluate this support ticket for complexity and routing.
Success: Provide complexity rating (1-5), recommended team assignment, 
estimated resolution time in hours, and 2-sentence justification."

Why: Success criteria guide the agent’s autonomous actions and ensure consistent output.

Provide Business Context

Goal: Enable the agent to make decisions aligned with business prioritiesExample:

Task: "Review this contract deviation request from {{customer.name}}.
Business context:
- Customer segment: {{customer.segment}}
- Strategic account: {{customer.is_strategic}}
- Revenue impact: ${{customer.annual_value}}
- Relationship tenure: {{customer.years}} years

Evaluate whether to approve deviation considering relationship value and risk."

Why: Business context enables better judgment about priorities and trade-offs.

Output Field Design

Balance Detail and Usability

Goal: Get enough information for decisions without overwhelming downstream logicExample:

Good balance:
- risk_level: Low/Medium/High (easy to use in IF statements)
- risk_score: 1-10 (precise for calculations or thresholds)
- key_risks: List of top 3-5 risks (detail for human review)
- reasoning: Brief explanation (audit trail)

Avoid:

Too sparse:
- risk: Some text blob (hard to use programmatically)

Too detailed:
- risk_factor_1, risk_factor_2, ... risk_factor_20 (overwhelming)

Design for Downstream Actions

Goal: Structure output to align with how you’ll use itIf you’ll route based on output:

Use categorical fields: risk_level (Low/Medium/High)
Enable: IF run_agent_task.risk_level = "High" → Route to senior team

If you’ll calculate or aggregate:

Use numeric fields: satisfaction_score (1-10)
Enable: IF run_agent_task.satisfaction_score < 7 → Alert CS team

If you’ll display to humans:

Use narrative fields: summary, reasoning, recommendations
Enable: Send Email with {{run_agent_task.recommendations}}

Testing Strategy

Test with Representative Scenarios

Test your agent task with various real-world cases:

Typical cases: Most common scenarios
Edge cases: Unusual or extreme situations
Ambiguous cases: Situations requiring judgment
Data variations: Different data completeness or quality

Testing Process:

Use the Test & Preview feature
Fill in value references with real data
Run the agent task
Evaluate output quality and format
Refine task definition if needed
Repeat until consistent quality achieved

Monitor and Iterate

After deployment:

Review early executions: Check first 10-20 runs manually
Track error rates: Monitor run_agent_task.success field
Gather feedback: Talk to users affected by agent decisions
Refine task definition: Adjust based on real-world performance
Update success criteria: Clarify based on observed issues

Continuous Improvement:

Agent task definitions can be updated without breaking workflows
Iterate based on performance data
Consider creating specialized agents for high-volume tasks

Error Handling Patterns

Always Check Success Field

Pattern:

Run Agent Task
  ↓
IF run_agent_task.success = true
  → Normal processing flow
OTHERWISE
  → Error handling:
    - Post Comment: "Agent task failed: {{run_agent_task.error_message}}"
    - Send Message to Teams: "@admins Agent task error in automation {{automation.name}}"
    - Make Assignment: Route to manual review
    - Update Record Fields: Mark as needing review

Why: Prevents downstream actions from using incomplete or invalid data.

Implement Graceful Degradation

Pattern:

Run Agent Task
  ↓
IF run_agent_task.success = true
  → Use agent insights for enhanced processing
OTHERWISE
  → Fall back to standard processing
    (may be less personalized but still functional)

Example:

Run Agent Task: Personalization analysis
  ↓
IF run_agent_task.success = true
  → Send Email: Personalized message with {{run_agent_task.recommendations}}
OTHERWISE
  → Send Email: Standard template (still functional)

Why: System remains operational even if agent task fails.

Agent Deletion Protection

When you attempt to delete an agent that’s used in automations:

System prevents deletion
Shows list of automations using the agent
Provides direct links to each automation

Before Deleting an Agent:

Check which automations use it
Update those automations to use different agent or different action
Test updated automations
Then delete the agent

Why This Matters: Prevents breaking live automations by accidentally removing required agents.

Advanced Patterns

Chaining Agent Tasks

For complex workflows, chain multiple agent tasks:

Data Collected
  ↓
Run Agent Task: "Initial Analysis"
  → Analyze raw data and identify key themes
  ↓
Run Agent Task: "Deep Dive"
  → Task: "Based on initial themes {{agent_task_1.themes}}, 
          conduct detailed analysis..."
  ↓
Run Agent Task: "Recommendations"
  → Task: "Given analysis {{agent_task_2.findings}}, 
          provide strategic recommendations..."
  ↓
Generate Report: Combine all agent insights

Use When: Single agent task would be too complex; breaking into stages improves quality.

Conditional Agent Invocation

Use agents only when intelligence is needed:

Record Updated
  ↓
IF simple_condition = true
  → Standard processing (fast, deterministic)
OTHERWISE
  → Run Agent Task (intelligent assessment)
  → Use agent insights for decision

Use When: Most cases are straightforward, but complex cases need intelligence.

Agent + Human Hybrid

Combine agent intelligence with human oversight:

Contract Submitted
  ↓
Run Agent Task: "Contract Assessment"
  ↓
IF run_agent_task.risk_level = "Low" AND run_agent_task.confidence > 0.9
  → Auto-approve (agent sufficient)
OTHERWISE
  → Start Approval Process (human review)
  → Context: Agent provided {{run_agent_task.reasoning}}

Use When: Agent provides valuable first-pass analysis, but humans make final decisions.

Integration with Other Features

Combine with AI File Reader

Document Uploaded
  ↓
AI File Analysis: Extract structured data
  ↓
Run Agent Task: "Interpret and Evaluate"
  → Task: "Based on extracted data {{ai_file_analysis.data}}, 
          evaluate completeness, identify concerns, recommend next steps"
  ↓
Use both structured data and agent insights in workflow

Combine with API Requests

Run Agent Task: "Research External Information"
  ↓
Send API Request: Fetch specific data based on agent findings
  → Endpoint: {{run_agent_task.recommended_data_source}}
  → Parameters: {{run_agent_task.query_parameters}}
  ↓
Run Agent Task: "Synthesize Results"
  → Task: "Combine research findings with API data to provide final recommendations"

Combine with Classification

Email Received
  ↓
AI Classification: Basic categorization
  ↓
IF ai_classification.category = "Complex"
  → Run Agent Task: Detailed analysis and routing
OTHERWISE
  → Standard routing logic

Import/Export Considerations

Good News: Automations with Run Agent Task actions export and import smoothly. What Exports:

Run Agent Task action configuration
Task definitions
Output field definitions
Agent references

What to Consider:

Agents themselves don’t export with the automation
When importing to new app, ensure required agents exist or create them
Agent names must match for import to work seamlessly

Best Practice:

Document which agents your automation uses
Create agents with consistent names across environments
Test imported automations thoroughly

Getting Started Checklist

Ready to build your first agent task automation? Follow this checklist:

Next Steps

Automation Actions Reference

See all available automation actions including Run Agent Task details

AI in Automations

Learn about other AI-powered automation capabilities

Agent Architecture

Understand how agents work and integrate with workflows

Best Practices

Master general automation and workflow best practices

Questions or feedback? The Run Agent Task action represents a new paradigm in workflow automation. As you explore its capabilities, your feedback helps us improve the feature and documentation.

Workflow & Automation

Agents

Working with Snowflake

Integration & Configuration

Data Management

​Agent Task Automation: The Best of Both Worlds

​The Core Concept

​Why This Matters

​The Limitations Before Run Agent Task

​The Hybrid Approach

Structured Reliability

Intelligent Autonomy

​Understanding the Run Agent Task Action

​Configuration Components

​1. Action Name

​2. Agent Selection

​3. Task Definition

​4. Output Type

​5. Testing & Preview

​When to Use Run Agent Task

​Ideal Use Cases

​When NOT to Use Run Agent Task

Deterministic Logic

Direct Data Operations

Standard Classifications

API Integrations

​The Headless Environment

​What This Means

​Best Practices for Headless Operation

​1. Provide Complete Context

​2. Define Clear Success Criteria

​3. Use Value References Extensively

​4. Anticipate Agent Needs

​Working with Structured Output

​Defining Output Fields

​Using Output in Subsequent Actions

​Error Handling with Structured Output

​Real-World Workflow Examples

​Example 1: Intelligent Order Processing

​Example 2: Smart Support Ticket Routing

​Example 3: Intelligent Document Review

​Best Practices

​Task Definition Quality

​Output Field Design

​Testing Strategy

​Error Handling Patterns

​Agent Deletion Protection

​Advanced Patterns

​Chaining Agent Tasks

​Conditional Agent Invocation

​Agent + Human Hybrid

​Integration with Other Features

​Combine with AI File Reader

​Combine with API Requests

​Combine with Classification

​Import/Export Considerations

​Getting Started Checklist

​Next Steps

Automation Actions Reference

AI in Automations

Agent Architecture

Best Practices

Agent Task Automation: The Best of Both Worlds

The Core Concept

Why This Matters

The Limitations Before Run Agent Task

The Hybrid Approach

Understanding the Run Agent Task Action

Configuration Components

1. Action Name

2. Agent Selection

3. Task Definition

4. Output Type

5. Testing & Preview

When to Use Run Agent Task

Ideal Use Cases

When NOT to Use Run Agent Task

The Headless Environment

What This Means

Best Practices for Headless Operation

1. Provide Complete Context

2. Define Clear Success Criteria

3. Use Value References Extensively

4. Anticipate Agent Needs

Working with Structured Output

Defining Output Fields

Using Output in Subsequent Actions

Error Handling with Structured Output

Real-World Workflow Examples

Example 1: Intelligent Order Processing

Example 2: Smart Support Ticket Routing

Example 3: Intelligent Document Review

Best Practices

Task Definition Quality

Output Field Design

Testing Strategy

Error Handling Patterns

Agent Deletion Protection

Advanced Patterns

Chaining Agent Tasks

Conditional Agent Invocation

Agent + Human Hybrid

Integration with Other Features

Combine with AI File Reader

Combine with API Requests

Combine with Classification

Import/Export Considerations

Getting Started Checklist

Next Steps