Async Task Handoff: Agents That Wait for External Events

End-of-lesson check

15 questions · take it digitally for instant feedback at tendril.neural-forge.io/learn/quiz/end-agentic-agent-async-task-handoff-creators

1. Which capability is most essential for an agent designed to wait for human approval that may take days?

   1. Faster processing to complete before approval arrives
   2. Continuous synchronous execution
   3. Durable execution that persists state across process restarts
   4. Elimination of all external dependencies

2. A developer chooses webhook-based handoff over polling for resuming an agent after an external API completes processing. What is the primary advantage of this choice?

   1. Webhooks eliminate the need for any server infrastructure
   2. Webhooks are free and have no operational cost
   3. Webhooks automatically retry failed requests forever
   4. Webhooks provide immediate notification when an event occurs rather than requiring repeated checks

3. What is a state checkpoint in the context of long-running async agents?

   1. A visual progress bar showing agent status to users
   2. A timeout mechanism that terminates stuck agents
   3. A saved snapshot of agent variables and progress that enables resumption after failure
   4. A log entry documenting each API call

4. Why is running an hour-long agent synchronously typically impractical?

   1. The agent would use too little CPU
   2. The process would hold resources hostage and prevent scaling, costing more and creating bottlenecks
   3. Long-running agents cannot make API calls
   4. Synchronous execution is always faster

5. Which framework is specifically mentioned in the material as an example of a durable execution system?

   1. Express
   2. Temporal
   3. Redux
   4. React

6. A developer tests agent resumption by killing the process mid-execution and restarting it. What failure mode is this testing?

   1. Process crash and restart recovery
   2. Network timeout failures
   3. API rate limiting
   4. User interface bugs

7. What does observability for paused agents primarily involve tracking?

   1. Only CPU and memory usage
   2. The source code of each agent
   3. Which agents are waiting, what they're waiting for, and how long they've been paused
   4. Network bandwidth consumption

8. When designing an async agent, what trade-off must be explicitly considered between cost and latency?

   1. Faster agents always cost less
   2. Cost and latency are unrelated in async agent design
   3. Pausing agents incurs idle compute costs but reduces response latency compared to polling
   4. Agents that wait longer always cost more due to retained memory

9. Which handoff signal architecture requires the agent to actively check for completion rather than being notified?

   1. Webhooks
   2. Polling
   3. Callbacks
   4. Event listeners

10. What operational complexity is introduced by stateful async agents that doesn't exist for stateless ones?

    1. Faster deployment pipelines
    2. Need to manage, persist, and recover state across failures
    3. Automatic horizontal scaling without configuration
    4. Reduced infrastructure costs

11. A task handoff signal should clearly define what for the agent to resume correctly?

    1. The cost of the operation
    2. The exact code to execute
    3. What triggers the resume event
    4. The agent's creator

12. What happens if an async agent lacks proper checkpoint design when it crashes?

    1. It automatically fixes itself on restart
    2. It converts to synchronous execution
    3. It must restart from the beginning, losing all progress
    4. It continues from where any other agent left off

13. Which approach best supports an agent task that spans multiple days with external human involvement?

    1. Running multiple parallel agents
    2. Durable execution with state checkpoints
    3. Synchronous execution with longer timeouts
    4. Eliminating all external dependencies

14. The material notes that AI cannot run hour-long agents synchronously without what?

    1. Infrastructure designed for long-running processes
    2. Special AI chips
    3. Human intervention
    4. A faster network

15. Why is polling described as an inadequate substitute for proper event-driven design?

    1. Events cannot be used with AI agents
    2. Polling requires more complex code than events
    3. Events are less reliable than polling
    4. Polling wastes resources checking for status and adds latency