Who is Muhammad Usman Akbar?

Muhammad Usman Akbar is a world-class AI Transformation Consultant and Agentic Architect focused on achieving 30x industrial efficiency through autonomous ecosystems.

What results can an AI Transformation Consultant provide?

By replacing manual work with autonomous AI workflows, a consultant like Muhammad Usman can deliver up to 30x growth in output while reducing operational overhead by 40%.

What is Agentic AI Orchestration?

It is the engineering of multi-agent systems where autonomous AI entities collaborate to manage complex industrial operations in production environments.

Combining Actors with Workflows

You've built actors that maintain state for individual entities. You've built workflows that orchestrate multi-step processes. Now the real power emerges: combining both to create systems where stateful entities participate in durable orchestration.

Consider an AI agent task management system. Each task needs its own state—title, status, deadline, assignee, history. That's perfect for a TaskActor. But completing a task isn't a single operation—it requires validation, assignment, notification, and status updates across multiple steps. That's perfect for a TaskProcessingWorkflow. The question isn't "actors OR workflows?" but "actors AND workflows working together."

The Decision Framework

When should you use actors, workflows, or both? Apply this analysis:

Use Actors When

Characteristic	Example
Entity has identity	User-123, Task-456, Device-789
Stateful ownership	Conversation history, task status, device settings
Turn-based access	Only one operation on this entity at a time
Entity timers	Deadline notifications, session timeouts

Use Workflows When

Characteristic	Example
Multi-step process	Validate -> Assign -> Notify -> Track
Durability required	Must survive crashes, complete after restart
Parallel execution	Process 10 items concurrently, aggregate results
Compensation needed	Undo step 2 if step 3 fails (saga pattern)
Human approval	Wait hours/days for external event

The Hybrid Model

The most powerful systems leverage the strengths of both:

Actor Responsibility	Workflow Responsibility
Own entity state (Ground Truth)	Orchestrate multi-entity processes
Enforce turn-based access	Manage long-running operations
Handle entity-specific timers	Coordinate parallel work
Maintain instance consistency	Implement global compensation logic

Pattern 1: Workflow Calling Actors

The most common hybrid pattern: workflows invoke actor methods through activities to update entity state at each orchestration step.

Replay-Safe Actor Invocations

Workflow code must be deterministic. Actor calls involve network I/O—you can't call them directly in workflow code. Instead, wrap actor invocations in activities:

python

from dapr.ext.workflow import WorkflowRuntime
from dapr.actor import ActorProxy, ActorId
from dataclasses import dataclass

wfr = WorkflowRuntime()

@dataclass
class TaskStatusUpdate:
    task_id: str
    status: str

# Activity that calls an actor
@wfr.activity
def update_task_status(ctx, update: TaskStatusUpdate) -> dict:
    """
    Activity wrapping actor invocation.
    Activities CAN be non-deterministic (IO, external calls).
    """
    from task_actor import TaskActorInterface

    proxy = ActorProxy.create(
        "TaskActor",
        ActorId(update.task_id),
        TaskActorInterface
    )

    # Call actor method
    result = proxy.UpdateStatus(update.status)
    return {"task_id": update.task_id, "new_status": update.status}

Pattern 2: Actor Triggering Workflow

Sometimes state changes in an actor should kick off a workflow. For example, when a TaskActor's status changes to "ready_for_processing", it should start the processing workflow.

Actor with Workflow Triggering

python

class TaskActor(Actor, TaskActorInterface):
    async def submit_for_processing(self, assignee: str) -> dict:
        """
        Submit task for processing - triggers a workflow.
        Actor coordinates with workflow for multi-step processing.
        """
        task_data = await self._state_manager.get_state("task_data")

        # Don't re-submit if already processing
        if task_data.get("workflow_instance"):
            return {"success": False, "reason": "Already submitted"}

        # Start workflow
        client = DaprWorkflowClient()
        instance_id = client.schedule_new_workflow(
            workflow="task_processing_workflow",
            input={"task_id": self.id.id, "assignee": assignee},
            instance_id=f"process-{self.id.id}"
        )

        # Update actor state with workflow reference
        task_data["status"] = "processing"
        task_data["workflow_instance"] = instance_id
        await self._state_manager.set_state("task_data", task_data)
        await self._state_manager.save_state()

        return {"success": True, "workflow_instance": instance_id}

Designing State Boundaries

The key to hybrid systems is clear ownership of state and responsibility.

State Component	Owner	Rationale
Entity Attributes	Actor	Title, description, and core identity state.
Current Status	Actor	The 'source of truth' for entity readiness.
Process Progress	Workflow	Which orchestration step is currently active.
Retry State	Workflow	Backoff timings and attempt counters.
Compensation	Workflow	History of what must be undone on failure.
History Log	Actor	Audit trail of human/system interactions.

Reflect on Your Skill

Your dapr-deployment skill now covers actors and workflows separately. Extend it with hybrid patterns.

Test Your Skill

text

Using my dapr-deployment skill, design a system for processing customer orders:
- Each order needs to track its own status and items
- Orders go through: validate -> charge payment -> ship -> notify
Should I use actors, workflows, or both? Explain the responsibilities.

Try With AI

Prompt 1: Design a Hybrid System

text

I'm building a task management system for AI agents. Help me design the architecture:
Requirements:
- Each task has status, assignee, deadline, and history
- Tasks go through: create -> validate -> assign -> process -> complete
- If assignment fails, task should return to unassigned state
What components do I need? Should I use actors, workflows, or both?
Show me the responsibilities of each component.

Prompt 2: Implement Workflow-to-Actor Communication

text

Show me how to implement a workflow activity that updates a TaskActor.
The workflow should:
1. Validate the task


2. Update TaskActor status to "validated"


3. Assign to a user
Include the activity functions and workflow code.

Prompt 3: Implement Actor-to-Workflow Triggering

text

Implement a TaskActor with a submit_for_processing method that:
1. Checks if task isn't already being processed

2. Starts a TaskProcessingWorkflow

3. Stores the workflow instance ID in actor state
Also show me how to query both actor state and workflow status together.

Safety Note: When actors trigger workflows, ensure idempotency. The actor should check if a workflow is already running before starting a new one. Multiple workflow instances processing the same entity can cause status corruption.