Adding changes to convert agentic to async

Author: jasonyang101

examples/tutorials/00_sync/000_hello_acp/manifest.yaml

@@ -61,7 +61,7 @@ agent:
 
   # Type of ACP to use
   # sync: Simple synchronous ACP implementation
-  # agentic: Advanced ACP with sub-types "base" or "temporal" (requires config)
+  # async: Asynchronous, non-blocking ACP implementation
   acp_type: sync
 
   # Description of what your agent does

examples/tutorials/10_async/00_base/000_hello_acp/README.md

@@ -44,6 +44,6 @@ Three handlers instead of one, giving you full control over task lifecycle. Task
 - Building towards production systems
 
 ## Why This Matters
-The task-based model is the foundation of production agents. Unlike sync agents where each message is independent, agentic agents maintain persistent tasks that can receive multiple events, store state, and have full lifecycle management. This is the stepping stone to Temporal-based agents.
+The task-based model is the foundation of production agents. Unlike sync agents where each message is independent, async agents maintain persistent tasks that can receive multiple events, store state, and have full lifecycle management. This is the stepping stone to Temporal-based agents.
 
 **Next:** [010_multiturn](../010_multiturn/) - Add conversation memory

examples/tutorials/10_async/00_base/000_hello_acp/manifest.yaml

@@ -106,7 +106,7 @@ deployment:
   global:
     agent:
       name: "ab000-hello-acp"
-      description: "An AgentEx agent that is not intelligent. It just shows how to implement the base agentic ACP type."
+      description: "An AgentEx agent that is not intelligent. It just shows how to implement the base async ACP type."
 
     # Default replica count
     replicaCount: 1

examples/tutorials/10_async/00_base/010_multiturn/README.md

@@ -1,27 +1,27 @@
-# [Agentic] Multiturn
+# [Async] Multiturn
 
-Handle multi-turn conversations in agentic agents with task-based state management. Each task maintains its own conversation history automatically.
+Handle multi-turn conversations in async agents with task-based state management. Each task maintains its own conversation history automatically.
 
 ## What You'll Learn
 - How tasks maintain conversation state across multiple exchanges
-- Difference between sync and agentic multiturn patterns
+- Difference between sync and async multiturn patterns
 - Building stateful conversational agents with minimal code
 
 ## Prerequisites
 - Development environment set up (see [main repo README](https://github.com/scaleapi/scale-agentex))
 - Backend services running: `make dev` from repository root
-- Understanding of basic agentic agents (see [000_hello_acp](../000_hello_acp/))
+- Understanding of basic async agents (see [000_hello_acp](../000_hello_acp/))
 
 ## Quick Start
 
 ```bash
-cd examples/tutorials/10_agentic/00_base/010_multiturn
+cd examples/tutorials/10_async/00_base/010_multiturn
 uv run agentex agents run --manifest manifest.yaml
 ```
 
 ## Key Pattern
 
-Unlike sync agents where you manually track conversation history, agentic agents automatically maintain state within each task:
+Unlike sync agents where you manually track conversation history, async agents automatically maintain state within each task:
 
 ```python
 @app.on_task_event_send()

examples/tutorials/10_async/00_base/010_multiturn/dev.ipynb

@@ -29,7 +29,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# (REQUIRED) Create a new task. For Agentic agents, you must create a task for messages to be associated with.\n",
+    "# (REQUIRED) Create a new task. For Async agents, you must create a task for messages to be associated with.\n",
     "import uuid\n",
     "\n",
     "rpc_response = client.agents.create_task(\n",

examples/tutorials/10_async/00_base/020_streaming/README.md

@@ -1,21 +1,21 @@
 # [Agentic] Streaming
 
-Stream responses in agentic agents using `adk.messages.create()` to send progressive updates. More flexible than sync streaming since you can send multiple messages at any time.
+Stream responses in async agents using `adk.messages.create()` to send progressive updates. More flexible than sync streaming since you can send multiple messages at any time.
 
 ## What You'll Learn
 - How to stream with explicit message creation
-- Difference between sync and agentic streaming patterns
+- Difference between sync and async streaming patterns
 - When to send multiple messages vs single streamed response
 
 ## Prerequisites
 - Development environment set up (see [main repo README](https://github.com/scaleapi/scale-agentex))
 - Backend services running: `make dev` from repository root
-- Understanding of agentic basics (see [000_hello_acp](../000_hello_acp/))
+- Understanding of async basics (see [000_hello_acp](../000_hello_acp/))
 
 ## Quick Start
 
 ```bash
-cd examples/tutorials/10_agentic/00_base/020_streaming
+cd examples/tutorials/10_async/00_base/020_streaming
 uv run agentex agents run --manifest manifest.yaml
 ```
 
@@ -33,7 +33,7 @@ async def handle_event_send(params: SendEventParams):
     await adk.messages.create(task_id=task_id, content=...)
 ```
 
-Unlike sync streaming (which uses async generators), agentic streaming uses explicit message creation calls, giving you more control over when and what to send.
+Unlike sync streaming (which uses async generators), async streaming uses explicit message creation calls, giving you more control over when and what to send.
 
 ## When to Use
 - Multi-step processes with intermediate results

examples/tutorials/10_async/00_base/030_tracing/README.md

@@ -11,12 +11,12 @@ Add observability to your agents with spans and traces using `adk.tracing.start_
 ## Prerequisites
 - Development environment set up (see [main repo README](https://github.com/scaleapi/scale-agentex))
 - Backend services running: `make dev` from repository root
-- Understanding of agentic agents (see [000_hello_acp](../000_hello_acp/))
+- Understanding of async agents (see [000_hello_acp](../000_hello_acp/))
 
 ## Quick Start
 
 ```bash
-cd examples/tutorials/10_agentic/00_base/030_tracing
+cd examples/tutorials/10_async/00_base/030_tracing
 uv run agentex agents run --manifest manifest.yaml
 ```
 

examples/tutorials/10_async/00_base/040_other_sdks/README.md

@@ -11,12 +11,12 @@ Agents are just Python code - integrate any SDK you want (OpenAI, Anthropic, Lan
 ## Prerequisites
 - Development environment set up (see [main repo README](https://github.com/scaleapi/scale-agentex))
 - Backend services running: `make dev` from repository root
-- Understanding of agentic agents (see [000_hello_acp](../000_hello_acp/))
+- Understanding of async agents (see [000_hello_acp](../000_hello_acp/))
 
 ## Quick Start
 
 ```bash
-cd examples/tutorials/10_agentic/00_base/040_other_sdks
+cd examples/tutorials/10_async/00_base/040_other_sdks
 uv run agentex agents run --manifest manifest.yaml
 ```
 

examples/tutorials/10_async/00_base/080_batch_events/README.md

@@ -1,22 +1,22 @@
 # [Agentic] Batch Events
 
-Demonstrates limitations of the base agentic protocol with concurrent event processing. When multiple events arrive rapidly, base agentic agents handle them sequentially, which can cause issues.
+Demonstrates limitations of the base async protocol with concurrent event processing. When multiple events arrive rapidly, base async agents handle them sequentially, which can cause issues.
 
 ## What You'll Learn
-- Limitations of non-Temporal agentic agents
+- Limitations of non-Temporal async agents
 - Race conditions and ordering issues in concurrent scenarios
 - When you need workflow orchestration
 - Why this motivates Temporal adoption
 
 ## Prerequisites
 - Development environment set up (see [main repo README](https://github.com/scaleapi/scale-agentex))
 - Backend services running: `make dev` from repository root
-- Understanding of agentic patterns (see previous tutorials)
+- Understanding of async patterns (see previous tutorials)
 
 ## Quick Start
 
 ```bash
-cd examples/tutorials/10_agentic/00_base/080_batch_events
+cd examples/tutorials/10_async/00_base/080_batch_events
 uv run agentex agents run --manifest manifest.yaml
 ```
 
@@ -27,15 +27,15 @@ This tutorial shows **when you need Temporal**. If your agent needs to:
 - Process multiple events in parallel safely
 - Maintain consistent state under concurrent load
 
-Then you should use Temporal workflows (see tutorials 10_agentic/10_temporal/) which provide:
+Then you should use Temporal workflows (see tutorials 10_async/10_temporal/) which provide:
 - Deterministic event ordering
 - Safe concurrent processing
 - Guaranteed state consistency
 
 This is the "breaking point" tutorial that motivates moving to Temporal for production agents.
 
 ## When to Use (This Pattern)
-This tutorial shows what NOT to use for production. Use base agentic agents only when:
+This tutorial shows what NOT to use for production. Use base async agents only when:
 - Events are infrequent (< 1 per second)
 - Order doesn't matter
 - State consistency isn't critical

examples/tutorials/10_async/00_base/090_multi_agent_non_temporal/README.md

@@ -49,13 +49,13 @@ The system uses a shared build configuration with type-safe interfaces:
 - Backend services running: `make dev` from repository root
 - Python 3.12+ and uv package manager
 - OpenAI API key (set `OPENAI_API_KEY` or create `.env` file)
-- Understanding of agentic patterns (see previous tutorials)
+- Understanding of async patterns (see previous tutorials)
 
 ### Running the System
 
 1. **Start all agents**:
    ```bash
-   cd examples/tutorials/10_agentic/00_base/090_multi_agent_non_temporal
+   cd examples/tutorials/10_async/00_base/090_multi_agent_non_temporal
    ./start-agents.sh start
    ```