> ## Documentation Index
> Fetch the complete documentation index at: https://docs.asteragents.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Call Agent Tool

> Call other agents on the Aster platform for specialized tasks and collaboration

## What it does

The Call Agent tool allows your agents to communicate with and delegate tasks to other agents on the Aster platform. Perfect for creating agent workflows, specialized task delegation, and building complex multi-agent systems.

## Key features

* Call any agent on your Aster platform
* Continue conversations across multiple interactions
* Maintain conversation threads for context
* Access to called agent's capabilities and knowledge
* Seamless agent-to-agent communication

## Parameters

| Parameter           | Type   | Required | Description                                                               |
| ------------------- | ------ | -------- | ------------------------------------------------------------------------- |
| `message`           | string | Yes      | The message to send to the target agent                                   |
| `agentName`         | string | Yes      | The name of the agent to call (matched case-insensitively)                |
| `respondToThreadId` | string | No       | ID of an existing thread to continue (creates new thread if not provided) |

## Common use cases

### Specialized task delegation

```
message: "Analyze this sales data and create a summary report with key insights"
agentName: "Data Analyst"
```

Delegate data analysis to a specialized analytics agent.

### Multi-step workflows

```
message: "Generate a marketing email for our new product launch"
agentName: "Marketing Writer"
respondToThreadId: "thread-789"
```

Continue a conversation thread for complex workflows.

### Expert consultation

```
message: "Review this code for security vulnerabilities and best practices"
agentName: "Security Reviewer"
```

Get expert review from specialized agents.

### Content creation pipeline

```
message: "Create a blog post outline about AI trends in 2024"
agentName: "Content Writer"
```

Start a content creation workflow with writing specialists.

### Quality assurance

```
message: "Review and fact-check this research report before publication"
agentName: "QA Reviewer"
respondToThreadId: "research-thread-303"
```

Add quality control steps to your workflows.

### Customer support escalation

```
message: "This customer has a complex technical issue that needs expert attention"
agentName: "Technical Support"
```

Escalate complex issues to specialized support agents.

## Agent collaboration patterns

### Sequential workflow

1. Agent A calls Agent B for initial analysis
2. Agent B returns results to Agent A
3. Agent A calls Agent C for final processing
4. Agent C delivers final output

### Parallel processing

* Call multiple specialized agents simultaneously
* Combine their outputs for comprehensive results
* Useful for multi-perspective analysis

### Iterative refinement

* Use `respondToThreadId` to continue conversations
* Refine outputs through multiple interactions
* Build complex solutions step by step

## Configuring callable agents

When you enable `call_agent` on an agent, you choose which agents it's allowed to call:

**Allow all agents in organization** (default) — The agent can call any non-deleted agent in the org. This is ideal when paired with [Manage Agents](/tools/manage_agents), which lets the agent dynamically discover available agents at runtime.

**Select specific agents** — Restrict the agent to a curated allowlist. Use the agent selector modal to pick exactly which agents are callable. This is better when you want tight control over which agents can be reached.

Both modes are configured in **Control Hub** → **Edit Agent** → **Call Agent** tool section.

## Finding agents to call

Agents are called by **name** (not ID). The agent can discover names by:

* Using [Manage Agents](/tools/manage_agents) with `action: "list"` to see all agents in the org
* Having agent names included in its system prompt
* Being told by the user which agent to call

## What you get back

The sub-agent runs asynchronously; the call returns a summary of its work:

| Field               | What it is                                                                |
| ------------------- | ------------------------------------------------------------------------- |
| `status`            | Outcome of the run                                                        |
| `summary.lastText`  | The full text of everything the sub-agent said                            |
| `respondToThreadId` | Pass this back on the next `call_agent` to continue the same conversation |
| `conversationUrl`   | Link to the sub-agent's conversation                                      |
| Generated files     | Any files the sub-agent produced, plus its message count                  |

<Tip>
  When pointing a user at the run, share `conversationUrl` as a markdown link — the raw thread
  id isn't clickable and sends people hunting through Control Hub history.
</Tip>

## Best practices

* Use clear, specific messages when calling agents
* Include relevant context and background information
* Use thread IDs to maintain conversation continuity
* Choose the right agent for each specific task
* Monitor agent interactions for workflow optimization
* Set up proper agent permissions and access controls

## Troubleshooting

**"Agent not found"**

* The agent name must match exactly (case-insensitive). Check spelling
* If using a specific allowlist, verify the target agent is in the list
* The target agent may have been deleted

**"No callable agents configured"**

* The agent has `call_agent` enabled but is set to "Select specific agents" with none selected
* Either toggle "Allow all agents" on, or select specific agents in the modal

## Related tools

* [Manage Agents](/tools/manage_agents) - Discover available agents before calling them
* [Send Email](/tools/send_email) - Notify stakeholders of agent interactions
* [Run Code](/tools/execute_python) - Process agent responses programmatically