Tasks

​

Overview

Tasks are GitHub Actions-style workflows that define multi-step actions in Julep. Think of them as recipes that tell an agent exactly how to accomplish a goal. For example, a task might outline the steps to “Summarize a Research Paper” or “Debug a Code Issue”.

Here are some of the key features of tasks:

• Connect multiple AI operations seamlessly
• Make decisions based on intermediate results
• Run operations in parallel for efficiency
• Integrate with external tools and APIs
• Maintain state throughout execution

​

Components

A task consists of several key components which can be broadly classified into:

​

Input Schema

name: Summarize Document
description: Create a concise summary of any document
input_schema:
  type: object
  properties:
    document_text:
      type: string
      description: The text to summarize

​

Tools

Tools are functions that can be used by an agent to perform tasks. Julep supports:

• User-defined functions
• System tools
• Integrations
• API calls

Learn more about tools here.

tools:
- name: internet_search
  description: Performs an internet search using Brave
  type: integration
  integration:
    provider: brave
    method: search
    setup:
      api_key: <BRAVE_API_KEY>

​

Sub-Workflows

A task can be made up of multiple sub-workflows. These sub-workflows can be named and can be used to break down complex tasks into smaller, more manageable pieces.

name: Summarize Document
description: Create a concise summary of any document

sample_sub_workflow:
- prompt: |-
    $ f'Tell me a joke about {steps[0].input.topic}:'

main:
- workflow: sample_sub_workflow
  arguments:
    topic: AI

​

Steps

Below is a table of all the steps that can be used in a task.

You can learn more about workflow steps as to how they work in the Workflow Steps section.

​

Context Variables

Tasks have access to three types of context:

​

Input Variables

Access input parameters:

- prompt: $ f'Hello {steps[0].input.user_name}'

​

Step Results

Use outputs from previous steps:

- evaluate: $ len(_.search_results)
- if: $ _.count > 0

​

Environment Context

Access agent and session data:

- prompt: $ f'Agent {agent.name} is helping you'

Here’s how these components work together:

name: Process Customer Feedback
description: Analyze and categorize customer feedback
input_schema:
  type: object
  required: ["feedback_text"]
  properties:
    feedback_text:
      type: string
    sentiment_analysis:
      type: boolean
      default: true

tools:
  - name: categorize
    integration:
      provider: classification
      method: categorize

main:
  - prompt: Analyze customer sentiment
  - tool: categorize
    arguments:
      text: $ steps[0].input.feedback_text

Learn more about tools here.

​

Metadata

Metadata is a key-value pair that can be used to categorize and filter tasks.

​

How to Use Tasks ?

​

Creating a Task

Here’s a simple task that summarizes a document and checks if the summary is too long. We first define the task in a YAML file and then create it using the Julep SDK.

name: Summarize Document
description: Create a concise summary of any document
input_schema:
  type: object
  properties:
    document_text:
      type: string
      description: The text to summarize

main:
  - prompt: |-
        $ f'''Analyze the following text and create a summary:
        {steps[0].input.document_text}'''
    unwrap: true
  - evaluate:
      too_long: $ len(_) > 500
  - if: $ _.too_long
    then:
      prompt: |-
        $ f'''Make the summary more concise:
        {steps[0].output}'''
    else: 
      evaluate:
        content: $ steps[0].output

​

Executing a Task

Here’s how to execute a task:

# Execute a task
execution = client.executions.create(
    task_id=task.id,
    input={
        "document_text": "This is a sample document"
    }
)

# Monitor progress
while True:
    result = client.executions.get(execution.id)
    if result.status in ["succeeded", "failed"]:
        break
    time.sleep(1)

​

Relationship to Other Concepts

This section will help you understand how tasks relate to other concepts in Julep.

​

Agents

Julep agents can power tasks by providing memory, context, or tools. Tasks are multi-step workflows designed for complex, automated execution. Whenever you create a task, you can associate it with an agent if you want to leverage that agent’s capabilities. Unlike sessions, tasks are not meant for real-time interaction; they run through a defined workflow to achieve a goal.

For example:

import yaml

# Create an agent
agent = client.agents.create(
    name="Customer Support Agent",
    about="An agent that handles customer support requests",
    model="gpt-4o",
)

# Add a tool to the agent
client.agents.tools.create(
    agent_id=agent.id,
    name="send_email",
    **yaml.safe_load("""
    type: integration
    integration:
      provider: email
      method: send
      setup:
        host: "smtp.example.com"
        port: 587
        user: "your_username"
        password: "your_password"
    """),
)

# Create a task that inherits this tool
task = client.tasks.create(
    agent_id=agent.id,
    name="Handle Support Request",
    **yaml.safe_load("""
    main:
    - tool: send_email
      arguments:
        to: $ steps[0].input.customer_email
        from: "support@julep.ai"
        subject: $ steps[0].input.subject
        body: $ steps[0].input.body
    """)
)

​

Tools

Task can leverage tools to perform complex operations. Tools can be defined in the task definition or can be associated with an agent. When you define a tool in the task definition, it is available to all steps in that task only. On the other hand, when you associate a tool with an agent, it is available to all the Tasks associated with that agent.

​

Best Practices

​

Next Steps

• Workflow Steps - Learn about all available step types
• Tools - Learn about tools and how to use them in tasks
• Sessions - Learn about sessions and how to use them in tasks