Processes

let task1 = ORTask(
    description: "Research AI trends",
    expectedOutput: "Research report"
)

let task2 = ORTask(
    description: """
    Write article based on research.
    Research data: {task_0_output}
    """,
    expectedOutput: "Article draft",
    context: [task1.id]
)

let task = ORTask(
    description: """
    Analyze data for {industry} sector.
    Focus on {metric} metrics.
    Time period: {period}
    """,
    expectedOutput: "Analysis report"
)

// Provide inputs at execution time
let inputs = OrbitInput(Metadata([
    "industry": .string("healthcare"),
    "metric": .string("efficiency"),
    "period": .string("Q4 2024")
]))

let result = try await orbit.start(inputs: inputs)

// Agent context is available in system message
let agent = Agent(
    role: "Financial Analyst",
    purpose: "Analyze financial data",
    context: """
    Expert in:
    - Financial modeling
    - Risk assessment
    - Market analysis
    """
)

// Tasks executed by this agent have access to this context
// through the system message

// Bad: Sequential when tasks are independent
let sequential = [
    fetchAPI1Task,      // Could run in parallel
    fetchAPI2Task,      // Could run in parallel
    fetchAPI3Task,      // Could run in parallel
    mergeTask
]

// Good: Use flow-based for parallelization
let flow = TaskFlow(tasks: [
    fetchAPI1Task,      // Parallel
    fetchAPI2Task,      // Parallel
    fetchAPI3Task,      // Parallel
    mergeTask          // Waits for all fetches
])

// Configure concurrent execution
let engine = TaskExecutionEngine(
    agentExecutor: executor,
    maxConcurrentTasks: 3  // Run fetches in parallel
)

// Create agent pool for common tasks
let workerAgents = (1...5).map { i in
    Agent(
        role: "Data Processor \(i)",
        purpose: "Process data efficiently",
        context: "Generic data processing agent",
        tools: ["data_processor"]
    )
}

// Hierarchical process will distribute work
let orbit = Orbit.create(
    agents: workerAgents,
    tasks: manyTasks,
    process: .hierarchical,
    manager: coordinator
)

// Balance parallelism with resource limits
let engine = TaskExecutionEngine(
    agentExecutor: executor,
    maxConcurrentTasks: 5,  // Don't overwhelm system
    enableVerboseLogging: false  // Reduce overhead
)

// Consider:
// - API rate limits (50-100 requests/min)
// - Memory constraints
// - CPU availability
// - LLM provider limits

// Critical path: stop on failure
let criticalFlow = TaskFlow(
    tasks: criticalTasks,
    stopOnFailure: true
)

// Best effort: continue on failure
let bestEffortFlow = TaskFlow(
    tasks: optionalTasks,
    stopOnFailure: false  // Collect all results
)

// Test suites: run all tests
let testFlow = TaskFlow(
    tasks: testTasks,
    stopOnFailure: false  // Run all tests
)

// For sequential: tasks run in array order
let tasks = [task1, task2, task3]  // Runs 1→2→3

// For hierarchical: manager decides order
// Solution: Use sequential if order matters

// For flow-based: declare dependencies
let task2 = ORTask(
    description: "Task 2",
    dependencies: [task1.id]  // Explicit dependency
)

// Always declare context
let task = ORTask(
    description: "Use data: {task_0_output}",
    expectedOutput: "Result",
    context: [previousTask.id]  // Required!
)

// Verify task index (0-based)
// task_0_output = first task (index 0)
// task_1_output = second task (index 1)

// Ensure dependency order
let dependent = ORTask(
    description: "Use {task_1_output}",
    context: [secondTask.id],
    dependencies: [secondTask.id]  // Flow-based
)

// Enable delegation
let manager = Agent(
    role: "Project Manager",
    purpose: "Delegate and coordinate tasks",
    context: """
    You are a project manager coordinating a team.

    Your responsibilities:
    1. Analyze each task's requirements
    2. Select the best agent for each task
    3. Assign tasks to appropriate team members
    4. Monitor progress and quality

    Available team members and their expertise:
    [List agents and their capabilities]
    """,
    allowDelegation: true,  // Required!
    tools: [
        "task_analyzer",
        "agent_evaluator",
        "task_delegator"
    ]
)

// Provide good worker context
let worker = Agent(
    role: "Backend Developer",
    purpose: "Develop backend services",
    context: "Expert in Swift, APIs, databases",
    tools: ["code_generator", "api_designer"]
)

// Identify the cycle
// Bad:
taskA.dependencies = [taskB.id]
taskB.dependencies = [taskA.id]  // Circular!

// Fix: Remove circular dependency
taskA.dependencies = []  // A first
taskB.dependencies = [taskA.id]  // B depends on A

// For complex graphs, visualize dependencies:
func printDependencyGraph(tasks: [ORTask]) {
    for task in tasks {
        print("\(task.id): depends on \(task.dependencies ?? [])")
    }
}

// Increase concurrency
let engine = TaskExecutionEngine(
    agentExecutor: executor,
    maxConcurrentTasks: 10  // Higher limit
)

// Reduce dependencies
// Bad: Each task depends on previous
task2.dependencies = [task1.id]
task3.dependencies = [task2.id]
task4.dependencies = [task3.id]

// Good: Only necessary dependencies
task2.dependencies = [task1.id]
task3.dependencies = [task1.id]  // Parallel with task2
task4.dependencies = [task2.id, task3.id]  // After both

// Batch small tasks
// Instead of 100 tiny tasks, create 10 batches of 10

// Extract only needed information
let summaryTask = ORTask(
    description: "Extract key points from research",
    expectedOutput: "Bullet list of 5 key findings"
)

// Use structured outputs
struct Summary: Codable, Sendable {
    let keyPoints: [String]  // Compact format
}

// Reference specific outputs, not all
let task = ORTask(
    description: "Use summary: {task_2_output}",
    context: [summaryTask.id]  // Only one task
    // Not: context: [task0, task1, task2, task3, ...]
)

// Enable context window management
let agent = Agent(
    role: "Agent",
    purpose: "Process data",
    context: "...",
    respectContextWindow: true  // Auto-prune
)