Solatis Documentation

Appearance

Building & Configuring Agents ​

Overview ​

Step-by-step guide to creating custom AI agents that automate your workflows. No coding required for basic agents, with advanced options for developers.

Quick Start ​

Create Your First Agent ​

Step 1: Choose Template

  1. Navigate to Automation → Agents
  2. Click "Create New Agent"
  3. Select template:
    • Meeting Processor
    • Document Analyzer
    • Task Creator
    • Custom (blank)

Step 2: Configure Basics

Name: Product Meeting Processor
Description: Processes product planning meetings and creates Jira tickets
Icon: 🚀

Step 3: Set Trigger

Trigger Type: Meeting Completed
Filters:
  - Calendar contains "Product"
  - Duration > 15 minutes
  - Participants include "Product Team"

Step 4: Add Actions

Actions:
1. Generate Transcript
2. Extract Action Items
3. Create Jira Tickets
4. Send Summary Email
5. Post to Slack

Step 5: Test & Deploy

1. Test with sample meeting
2. Review results
3. Adjust configuration
4. Enable agent
5. Monitor performance

Agent Builder Interface ​

Visual Builder ​

No-Code Interface:

┌─────────────────────────────────────┐
│  Agent: Meeting Processor          │
├─────────────────────────────────────┤
│                                     │
│  ┌──────────┐                      │
│  │ Trigger  │                      │
│  │ Meeting  │                      │
│  │ Ends     │                      │
│  └────┬─────┘                      │
│       │                            │
│  ┌────▼──────────┐                 │
│  │ Generate      │                 │
│  │ Transcript    │                 │
│  └────┬──────────┘                 │
│       │                            │
│  ┌────▼──────────┐                 │
│  │ Extract       │                 │
│  │ Action Items  │                 │
│  └────┬──────────┘                 │
│       │                            │
│  ┌────▼──────────┐                 │
│  │ Create        │                 │
│  │ Jira Tickets  │                 │
│  └───────────────┘                 │
│                                     │
│  [Test] [Save] [Deploy]            │
└─────────────────────────────────────┘

Code Editor (Advanced) ​

YAML Configuration:

yaml
name: meeting-processor
version: 1.0
trigger:
  type: event
  source: meetings
  filter:
    calendar: "Product Team"
    min_duration: 900 # 15 minutes
    
actions:
  - name: transcribe
    service: solatis.transcribe
    timeout: 600
    
  - name: extract_items
    service: solatis.extract_action_items
    requires: transcribe
    parameters:
      format: structured
      confidence_threshold: 0.8
      
  - name: create_tickets
    service: jira.create_issues
    requires: extract_items
    for_each: action_item
    parameters:
      project: PROD
      issue_type: Task
      assignee: "{{action_item.assignee}}"
      due_date: "{{action_item.due_date}}"
      
  - name: notify
    service: slack.post_message
    requires: create_tickets
    parameters:
      channel: "#product-team"
      template: meeting_summary

Configuration Options ​

Triggers ​

Event-Based:

yaml
trigger:
  type: event
  events:
    - meeting.completed
    - document.uploaded
    - task.created
  filters:
    workspace: "{{workspace_id}}"
    tags: ["important"]

Time-Based:

yaml
trigger:
  type: schedule
  cron: "0 9 * * MON"  # Every Monday at 9 AM
  timezone: "America/New_York"

Manual:

yaml
trigger:
  type: manual
  permissions:
    - role: admin
    - role: editor

Conditional:

yaml
trigger:
  type: conditional
  condition: |
    document.size > 1MB AND
    document.type == 'contract' AND
    workspace.name == 'Legal'

Actions ​

Built-in Actions:

AI Processing:

  • solatis.transcribe - Audio to text
  • solatis.summarize - Generate summary
  • solatis.extract_entities - Find people, dates, etc.
  • solatis.extract_action_items - Find tasks
  • solatis.chat - Ask AI questions

Integrations:

  • jira.create_issue - Create Jira ticket
  • asana.create_task - Create Asana task
  • slack.post_message - Post to Slack
  • email.send - Send email
  • calendar.create_event - Create meeting

Data Operations:

  • solatis.search - Search documents
  • solatis.create_document - Create doc
  • solatis.update_document - Update doc
  • database.query - Query database
  • http.request - API call

Parameters ​

Static Values:

yaml
parameters:
  project: "PROD"
  priority: "Medium"
  labels: ["auto-generated"]

Dynamic Values:

yaml
parameters:
  assignee: "{{action_item.assignee}}"
  due_date: "{{action_item.due_date}}"
  title: "{{meeting.title}} - Action Item"
  description: |
    From meeting: {{meeting.title}}
    Date: {{meeting.date}}
    Context: {{action_item.context}}

Transformations:

yaml
parameters:
  priority: "{{action_item.priority | uppercase}}"
  due_date: "{{action_item.date | add_days(7) | format('YYYY-MM-DD')}}"
  assignee: "{{mention | lookup_user | get('email')}}"

Error Handling ​

Retry Logic:

yaml
error_handling:
  retry:
    max_attempts: 3
    backoff: exponential
    initial_delay: 1000  # milliseconds
    max_delay: 30000

Fallback Actions:

yaml
error_handling:
  on_failure:
    - action: log_error
    - action: notify_admin
      parameters:
        channel: "#alerts"
        message: "Agent failed: {{error.message}}"
    - action: create_manual_task
      parameters:
        title: "Fix agent: {{agent.name}}"
        assignee: "{{agent.owner}}"

Timeout Handling:

yaml
actions:
  - name: long_running_task
    timeout: 300000  # 5 minutes
    on_timeout:
      action: cancel_and_notify

Advanced Features ​

Conditional Logic ​

If-Then-Else:

yaml
actions:
  - name: check_priority
    service: solatis.evaluate
    condition: "{{action_item.priority == 'high'}}"
    
  - name: urgent_flow
    service: jira.create_issue
    if: "{{check_priority.result == true}}"
    parameters:
      priority: "Highest"
      labels: ["urgent"]
      
  - name: normal_flow
    service: jira.create_issue
    if: "{{check_priority.result == false}}"
    parameters:
      priority: "Medium"

Loops & Iteration ​

For Each:

yaml
actions:
  - name: create_tickets
    service: jira.create_issue
    for_each: "{{action_items}}"
    parameters:
      summary: "{{item.title}}"
      assignee: "{{item.assignee}}"

While Loop:

yaml
actions:
  - name: process_batch
    service: solatis.process_documents
    while: "{{documents.remaining > 0}}"
    parameters:
      batch_size: 10

Data Transformation ​

Extract & Transform:

yaml
actions:
  - name: extract_data
    service: solatis.extract_entities
    output:
      people: "{{entities | filter('type', 'person') | map('name')}}"
      dates: "{{entities | filter('type', 'date') | map('value')}}"
      
  - name: format_data
    service: custom.transform
    input:
      formatted_people: "{{extract_data.people | join(', ')}}"
      next_date: "{{extract_data.dates | first}}"

Parallel Execution ​

Run Actions in Parallel:

yaml
actions:
  - name: parallel_group
    type: parallel
    actions:
      - name: create_jira
        service: jira.create_issue
        
      - name: post_slack
        service: slack.post_message
        
      - name: send_email
        service: email.send
    
    wait_for: all  # or 'any' or 'first'

Testing & Debugging ​

Test Mode ​

Test with Sample Data:

1. Click "Test Agent"
2. Select test data source:
   - Sample meeting
   - Sample document
   - Custom JSON
3. Run test
4. Review results
5. Check logs

Test Output:

json
{
  "status": "success",
  "duration": 12.3,
  "actions_completed": 5,
  "results": {
    "transcribe": {
      "status": "success",
      "duration": 8.2,
      "words": 1247
    },
    "extract_items": {
      "status": "success",
      "duration": 2.1,
      "items_found": 3
    },
    "create_tickets": {
      "status": "success",
      "duration": 1.8,
      "tickets_created": ["PROD-123", "PROD-124", "PROD-125"]
    }
  }
}

Debug Mode ​

Detailed Logging:

yaml
agent:
  name: meeting-processor
  debug: true
  log_level: verbose
  
  logging:
    - action_inputs
    - action_outputs
    - transformations
    - api_calls
    - errors

Log Output:

[2024-10-11 14:30:00] Agent started: meeting-processor
[2024-10-11 14:30:01] Trigger matched: meeting.completed
[2024-10-11 14:30:01] Action: transcribe (starting)
[2024-10-11 14:30:09] Action: transcribe (completed, 8.2s)
[2024-10-11 14:30:09] Output: 1247 words transcribed
[2024-10-11 14:30:09] Action: extract_items (starting)
[2024-10-11 14:30:11] Action: extract_items (completed, 2.1s)
[2024-10-11 14:30:11] Output: 3 action items found
[2024-10-11 14:30:11] Action: create_tickets (starting)
[2024-10-11 14:30:13] Created ticket: PROD-123
[2024-10-11 14:30:13] Created ticket: PROD-124
[2024-10-11 14:30:13] Created ticket: PROD-125
[2024-10-11 14:30:13] Action: create_tickets (completed, 1.8s)
[2024-10-11 14:30:13] Agent completed: success

Deployment ​

Deploy Options ​

Gradual Rollout:

yaml
deployment:
  strategy: gradual
  stages:
    - percentage: 10
      duration: 24h
    - percentage: 50
      duration: 48h
    - percentage: 100

A/B Testing:

yaml
deployment:
  strategy: ab_test
  variants:
    - name: version_a
      percentage: 50
      config: agent_v1.yaml
    - name: version_b
      percentage: 50
      config: agent_v2.yaml
  duration: 7d

Monitoring ​

Performance Metrics:

  • Execution count
  • Success rate
  • Average duration
  • Error rate
  • Cost per execution

Alerts:

yaml
monitoring:
  alerts:
    - condition: "error_rate > 0.05"
      action: notify
      channel: "#alerts"
      
    - condition: "avg_duration > 300"
      action: notify
      message: "Agent running slow"
      
    - condition: "executions_per_hour > 1000"
      action: throttle
      limit: 500

Best Practices ​

Agent Design:

  • Start simple, add complexity gradually
  • Single responsibility per agent
  • Clear naming conventions
  • Document expected behavior
  • Include error handling
  • Log important events

Performance:

  • Minimize API calls
  • Cache when possible
  • Use parallel execution
  • Set appropriate timeouts
  • Monitor costs

Security:

  • Least privilege access
  • Validate inputs
  • Sanitize outputs
  • Encrypt secrets
  • Audit logs

Next Steps ​

Last Updated: October 11, 2025

Released under the MIT License.

Copyright © 2026 Solatis