Description

CrewAI Bug Report: crew.kickoff() Truncates Output vs Task.execute_sync()

Summary

When using crew.kickoff() to execute a single-agent, single-task crew, the output is severely truncated (7-227 characters instead of 2500-5700 characters). However, calling task.execute_sync(agent) directly on the same task and agent produces complete output.

Issue affects both OpenAI and Bedrock providers, suggesting it's a CrewAI Crew orchestration issue, not provider-specific.

Environment

• CrewAI Version: Latest (as of 2026-02-25)
• Python: 3.12
• OS: macOS (Darwin 25.3.0)
• LLM Providers Tested:
  • OpenAI (gpt-4o-mini) - ✅ Works with execute_sync(), ❌ Fails with crew.kickoff()
  • AWS Bedrock (anthropic.claude-3-haiku, anthropic.claude-sonnet-4-6) - ✅ Works with litellm direct, ❌ Fails with crew.kickoff()

Expected Behavior

crew.kickoff() should return the complete LLM-generated output from the task, which is 2500-5700 characters of valid JSON.

Actual Behavior

crew.kickoff() returns only the first 7-227 characters of output, typically truncated mid-sentence like:

```json
{
    "selected_factors": [
        {
            "identifier": "CX_IRC_TRS_US_USD",
            "name": "USD Government Bond Yield Curve",
            "category": "Interest",
            "description": "Treasury Zero Interest Rate Curve for United States of America USD. The Treasury yield curve represents the yields (interest rates) on government bonds across different maturities (e.g., 3-month, 2-year, 10-year, 30-year). It is one of the most important indicators in financ...

Note: Output ends abruptly at "financ..." (total 227 chars)

Workaround that Works

Calling task.execute_sync(agent) directly instead of crew.kickoff() produces complete output:

# ❌ FAILS - Truncated output (7-227 chars)
crew = Crew(
    agents=[agent],
    tasks=[task],
    process=Process.sequential,
    verbose=True,
    memory=False,
)
result = crew.kickoff()
output = result.raw  # Only 7-227 characters!

# ✅ WORKS - Complete output (2500-5700 chars)
task.execute_sync(agent=agent)
output = task.output.raw  # Full response!

Minimal Reproduction Case

Test Case 1: Using crew.kickoff() (FAILS)

from crewai import Agent, Task, Crew, Process
from pathlib import Path

# Create agent
agent = Agent(
    role="Test Agent",
    goal="Return a large JSON response",
    backstory="You are a test agent that returns detailed JSON.",
    llm="openai/gpt-4o-mini",  # Also fails with bedrock/anthropic.claude-3-haiku-20240307-v1:0
    verbose=True,
    max_iter=3,
)

# Create task that should return large JSON (~2500+ chars)
task = Task(
    description="""Return a JSON object listing 5 US Treasury risk factors with detailed descriptions.

    For EACH factor provide:
    - identifier: factor ID
    - name: factor name
    - description: 2-3 sentences about the factor
    - country: United States
    - currency: USD

    Expected JSON format:
    ```json
    {
      "selected_factors": [
        {
          "identifier": "...",
          "name": "...",
          "description": "...",
          "country": "United States",
          "currency": "USD"
        }
      ]
    }
    ```
    """,
    expected_output="A JSON object with selected_factors array containing 5 detailed factor entries",
    agent=agent,
)

# Method 1: Using crew.kickoff() - FAILS (truncated)
crew = Crew(
    agents=[agent],
    tasks=[task],
    process=Process.sequential,
    verbose=True,
    memory=False,
)

result = crew.kickoff()

# Extract output
output = None
if hasattr(result, 'raw'):
    output = result.raw
elif hasattr(result, 'output'):
    output = result.output
elif task.output and hasattr(task.output, 'raw'):
    output = task.output.raw

print(f"crew.kickoff() output length: {len(output) if output else 0}")
print(f"crew.kickoff() output preview: {output[:500] if output else 'None'}")
# Expected: 2500+ chars
# Actual: 7-227 chars (truncated)

Test Case 2: Using task.execute_sync() (WORKS)

# Same agent and task as above

# Method 2: Using task.execute_sync() - WORKS (complete)
task.execute_sync(agent=agent)
output = task.output.raw if task.output else None

print(f"execute_sync() output length: {len(output) if output else 0}")
print(f"execute_sync() output preview: {output[:500] if output else 'None'}")
# Expected: 2500+ chars
# Actual: 2500+ chars (complete!)

Detailed Investigation Results

Evidence from Diagnostic Tests

Key Finding: The isolated test with crew.kickoff() worked (2552 chars), but the same code in the full workflow failed (7 chars). This suggests interaction between multiple crew executions or some state issue.

Truncation Patterns Observed

1. Minimum truncation: Exactly "```json" (7 characters)
2. Moderate truncation: 227 characters, cuts off mid-word
3. No truncation: 2500-5700 characters when using execute_sync()

The fact that output is truncated to exactly "```json" suggests CrewAI is stopping output capture at a specific point, possibly:

• Buffer size limit
• Stream reading stopping early
• Task completion signaled prematurely
• Output object has size limits

What We've Ruled Out

❌ NOT a provider issue - Happens with both OpenAI and Bedrock ❌ NOT an LLM token limit - litellm direct calls work fine ❌ NOT max_tokens configuration - Setting max_tokens=4096 doesn't help with crew.kickoff() ❌ NOT task definition - Same task works with execute_sync() ❌ NOT agent configuration - Same agent works with execute_sync()

✅ IS a Crew orchestration issue - Only crew.kickoff() fails

Additional Context

Bedrock-Specific Finding

CrewAI's BedrockCompletion has max_tokens=None by default, which causes Bedrock API to use a low default (~256 tokens). We fixed this by setting:

if isinstance(agent.llm, BedrockCompletion):
    if agent.llm.max_tokens is None:
        agent.llm.max_tokens = 4096

However, this fix alone doesn't solve the crew.kickoff() truncation issue - it only helps when using execute_sync().

Possible Root Causes in CrewAI Code

Based on investigation, the issue may be in:

1. Crew.kickoff() output handling - May have buffer/size limits
2. Task output object assignment - crew.kickoff() may not properly assign task.output
3. Streaming/buffering logic - May stop reading LLM stream early
4. Multiple crew interactions - State pollution between successive crew.kickoff() calls

Steps to Reproduce

1. Create an agent with any LLM (OpenAI or Bedrock)
2. Create a task that expects 2000+ character JSON output
3. Create a Crew with the agent and task
4. Call crew.kickoff() and check result.raw length
5. Compare with calling task.execute_sync(agent) and checking task.output.raw length

Workaround for Production

Replace all crew.kickoff() calls with direct task.execute_sync():

# Instead of:
# crew = Crew(agents=[agent], tasks=[task], ...)
# result = crew.kickoff()

# Use:
task.execute_sync(agent=agent)
output = task.output.raw

This works reliably and produces complete output.

Impact

HIGH - This bug affects any CrewAI usage where LLM responses exceed ~250 characters, which is most real-world applications. The workaround requires bypassing CrewAI's main orchestration API (crew.kickoff()), defeating the purpose of using CrewAI.

Request

Please investigate the Crew.kickoff() implementation to identify where output is being truncated. The fact that task.execute_sync() works suggests the issue is in the Crew orchestration layer, not the underlying task execution.

Generated: 2026-02-25 Reporter: System running risk factor selection agents Test Files: Available upon request (test_rfsa_minimal.py, test_bedrock_output_truncation.py)

Steps to Reproduce

1. Create an agent with any LLM (OpenAI or Bedrock)
2. Create a task that expects 2000+ character JSON output
3. Create a Crew with the agent and task
4. Call crew.kickoff() and check result.raw length
5. Compare with calling task.execute_sync(agent) and checking task.output.raw length

Expected behavior

crew.kickoff() should return the complete LLM-generated output from the task, which is 2500-5700 characters of valid JSON.

Screenshots/Code snippets

Test Case 1: Using crew.kickoff() (FAILS)

from crewai import Agent, Task, Crew, Process
from pathlib import Path

# Create agent
agent = Agent(
    role="Test Agent",
    goal="Return a large JSON response",
    backstory="You are a test agent that returns detailed JSON.",
    llm="openai/gpt-4o-mini",  # Also fails with bedrock/anthropic.claude-3-haiku-20240307-v1:0
    verbose=True,
    max_iter=3,
)

# Create task that should return large JSON (~2500+ chars)
task = Task(
    description="""Return a JSON object listing 5 US Treasury risk factors with detailed descriptions.

    For EACH factor provide:
    - identifier: factor ID
    - name: factor name
    - description: 2-3 sentences about the factor
    - country: United States
    - currency: USD

    Expected JSON format:
    ```json
    {
      "selected_factors": [
        {
          "identifier": "...",
          "name": "...",
          "description": "...",
          "country": "United States",
          "currency": "USD"
        }
      ]
    }
    ```
    """,
    expected_output="A JSON object with selected_factors array containing 5 detailed factor entries",
    agent=agent,
)

# Method 1: Using crew.kickoff() - FAILS (truncated)
crew = Crew(
    agents=[agent],
    tasks=[task],
    process=Process.sequential,
    verbose=True,
    memory=False,
)

result = crew.kickoff()

# Extract output
output = None
if hasattr(result, 'raw'):
    output = result.raw
elif hasattr(result, 'output'):
    output = result.output
elif task.output and hasattr(task.output, 'raw'):
    output = task.output.raw

print(f"crew.kickoff() output length: {len(output) if output else 0}")
print(f"crew.kickoff() output preview: {output[:500] if output else 'None'}")
# Expected: 2500+ chars
# Actual: 7-227 chars (truncated)

Test Case 2: Using task.execute_sync() (WORKS)

# Same agent and task as above

# Method 2: Using task.execute_sync() - WORKS (complete)
task.execute_sync(agent=agent)
output = task.output.raw if task.output else None

print(f"execute_sync() output length: {len(output) if output else 0}")
print(f"execute_sync() output preview: {output[:500] if output else 'None'}")
# Expected: 2500+ chars
# Actual: 2500+ chars (complete!)

Operating System

Other (specify in additional context)

Python Version

3.12

crewAI Version

Latest (as of 2026-02-25)

crewAI Tools Version

• OpenAI (gpt-4o-mini) - ✅ Works with execute_sync(), ❌ Fails with crew.kickoff() - AWS Bedrock (anthropic.claude-3-haiku, anthropic.claude-sonnet-4-6) - ✅ Works with litellm direct, ❌ Fails with crew.kickoff()

Virtual Environment

Venv

Evidence

Evidence from Diagnostic Tests

Key Finding: The isolated test with crew.kickoff() worked (2552 chars), but the same code in the full workflow failed (7 chars). This suggests interaction between multiple crew executions or some state issue.

Possible Solution

Workaround for Production

Replace all crew.kickoff() calls with direct task.execute_sync():

# Instead of:
# crew = Crew(agents=[agent], tasks=[task], ...)
# result = crew.kickoff()

# Use:
task.execute_sync(agent=agent)
output = task.output.raw

This works reliably and produces complete output.

Additional context

• OpenAI (gpt-4o-mini) - ✅ Works with execute_sync(), ❌ Fails with crew.kickoff()
• AWS Bedrock (anthropic.claude-3-haiku, anthropic.claude-sonnet-4-6) - ✅ Works with litellm direct, ❌ Fails with crew.kickoff()