Skip to main content
Task Studio is Athena’s platform for building custom tools that extend agent capabilities with specialized functionality. Create Python scripts that agents can invoke to perform custom workflows, integrate with external systems, and automate complex processes.
This feature requires basic Python programming knowledge. For technical assistance, contact team@athenaintel.com.

​
Overview

Task Studio enables you to build custom tools using Python scripts that agents can invoke. These tools can interact with external APIs, process data, orchestrate workflows, and leverage the full Python ecosystem alongside the Athena SDK for seamless integration with Athena’s AI capabilities.

​
Key Features

​
In-Browser Python Editor

Task Builder provides a complete development environment in your browser:
  • Built-in Code Editor: Write and edit Python scripts with syntax highlighting
  • Athena SDK Integration: Direct access to Athena agents and capabilities
  • Live Testing: Test scripts and view results side-by-side with your code
  • Deployment: One-click deployment to make tools available to agents

​
Automated Execution

Tasks can be configured to run automatically through:
  • Event Triggers: Execute when specific events occur (receiving emails, file uploads, meeting completion)
  • Schedules: Run at regular intervals (daily, weekly, monthly) at specific times
  • Manual Invocation: Run on-demand through the Task Studio interface or via agent commands

​
Agent Integration

Once deployed, custom tasks become tools that:
  • Agents can invoke through natural language commands in Chat
  • Appear in the agent’s toolkit for specialized operations
  • Can be shared across multiple agents in your workspace
  • Integrate seamlessly with Athena’s built-in capabilities

​
Creating a Custom Tool

1

Open Task Builder

Navigate to Task Studio → Builder. Enter the name of your task and click Create Task.
2

Write Your Python Script

In the built-in code editor, write your custom Python script. The script must have a main function that serves as the entry point:
def main(param1: str, param2: int):
    """
    Tool implementation
    
    Args:
        param1: Description of first parameter
        param2: Description of second parameter
    """
    result = process_data(param1, param2)
    return result
Important Notes:
  • Type annotations are highly recommended as they’re used to generate the UI form
  • The main function’s arguments define the tool’s input specification
  • Return values should be JSON-serializable for agent consumption
3

Test Your Script

Use the side-by-side testing interface to run your script and view logs and results. Make necessary adjustments until your tool works as expected.
4

Deploy to Task Studio

Click Deploy to make your task available in Task Studio Home where you can configure triggers, schedules, and enable it for agent use.

​
Configuring Task Automation

Once deployed, configure how your task runs:

​
Set a Schedule

Define when your task should automatically run:
  • Daily, weekly, or monthly intervals
  • Specific times (e.g., 9:00 AM every Monday)
  • Custom cron expressions for advanced scheduling

​
Set a Trigger

Configure event-based execution:
  • Email Trigger: Run when Athena receives an email at a custom address
  • File Upload: Execute when files are uploaded to specific locations
  • Meeting Completion: Trigger after meeting recordings are processed

​
Email Notifications

Receive email notifications when tasks complete:
  1. Set an email trigger with a custom email address
  2. Send emails to that address to trigger the task
  3. Receive completion notifications with task results

​
Use Cases & Examples

Integrate Athena Agents

Build scripts that leverage Athena agents for research, data gathering, and analysis. Agents can search the web, visit websites, and compile comprehensive summaries.

Connect External Systems

Integrate with Salesforce, databases, and other enterprise systems. Automatically extract data, process it with Athena agents, and keep your systems in sync.

Data Extraction Pipelines

Create customized data extraction pipelines using the Athena SDK. Extract structured data from documents like lease ledgers, contracts, and manuals.

Workflow Automation

Automate multi-step business processes that combine data processing, API calls, and agent interactions for complex workflow orchestration.

​
Example: Salesforce Integration

from athena_sdk import AthenaClient

def main(account_limit: int = 20):
    """
    Connects to Salesforce, extracts top customer accounts,
    and gathers recent news about each customer
    
    Args:
        account_limit: Number of top accounts to process
    """
    client = AthenaClient()
    
    accounts = get_salesforce_accounts(limit=account_limit)
    
    results = []
    for account in accounts:
        news = client.agents.research(
            query=f"Find recent news about {account['name']}",
            max_results=5
        )
        results.append({
            'account': account,
            'news': news
        })
    
    return results

​
Best Practices

Use Type Annotations

Add type hints to your main function parameters for automatic UI form generation and input validation

Clear Documentation

Write descriptive docstrings explaining what your tool does and what each parameter means

Error Handling

Implement robust error handling to return meaningful error messages for debugging

Test Thoroughly

Use the built-in testing interface to verify your tool works correctly before deployment

Leverage Athena SDK

Use the Athena SDK to access agents, search capabilities, and other platform features

Keep Tasks Focused

Build single-purpose tools that do one thing well, then combine them for complex workflows

Task Studio Home

Learn about task automation, triggers, and schedules

Task Builder

Detailed guide on using the Task Builder interface

Task Runs

Monitor and manage task execution history

Athena SDK

API reference for the Athena SDK

Create Your Agent

Configure agents to use your custom tools

Workflows

Explore example workflows and integrations
⌘I