Multi-Agent Systems on Producthunt daily

dimos

Sun, 15 Mar 2026 15:50:50 +0800

dimensionalOS/dimos

The Agentive Operating System for Physical Space

Hardware • Installation • Agent CLI & MCP • Blueprints • Development

⚠️ Pre-Release Beta ⚠️

Intro

Dimensional is the modern operating system for generalist robotics. We are setting the next-generation SDK standard, integrating with the majority of robot manufacturers.

With a simple install and no ROS required, build physical applications entirely in python that run on any humanoid, quadruped, or drone.

Dimensional is agent native – “vibecode” your robots in natural language and build (local & hosted) multi-agent systems that work seamlessly with your hardware. Agents run as native modules — subscribing to any embedded stream, from perception (lidar, camera) and spatial memory down to control loops and motor drivers.


Navigation and Mapping SLAM, dynamic obstacle avoidance, route planning, and autonomous exploration — via both DimOS native and ROS Watch video	Perception Detectors, 3d projections, VLMs, Audio processing

Agentive Control, MCP "hey Robot, go find the kitchen" Watch video	Spatial Memory Spatio-temporal RAG, Dynamic memory, Object localization and permanence Watch video

Hardware

Quadruped	Humanoid	Arm	Drone	Misc
🟩 Unitree Go2 pro/air 🟥 Unitree B1	🟨 Unitree G1	🟨 Xarm 🟨 AgileX Piper	🟧 MAVLink 🟧 DJI Mavic	🟥 Force Torque Sensor

🟩 stable 🟨 beta 🟧 alpha 🟥 experimental

[!IMPORTANT] 🤖 Direct your favorite Agent (OpenClaw, Claude Code, etc.) to AGENTS.md and our CLI and MCP interfaces to start building powerful Dimensional applications.

Installation

Interactive Install

`1`	`curl -fsSL https://raw.githubusercontent.com/dimensionalOS/dimos/main/scripts/install.sh \| bash`

See scripts/install.sh --help for non-interactive and advanced options.

Manual System Install

To set up your system dependencies, follow one of these guides:

Full system requirements, tested configs, and dependency tiers: docs/requirements.md

Python Install

Quickstart

uv venv --python "3.12"
source .venv/bin/activate
uv pip install 'dimos[base,unitree]'

# Replay a recorded quadruped session (no hardware needed)
# NOTE: First run will show a black rerun window while ~75 MB downloads from LFS
dimos --replay run unitree-go2

# Install with simulation support
uv pip install 'dimos[base,unitree,sim]'

# Run quadruped in MuJoCo simulation
dimos --simulation run unitree-go2

# Run humanoid in simulation
dimos --simulation run unitree-g1-sim

1
2
3

# Control a real robot (Unitree quadruped over WebRTC)
export ROBOT_IP=<YOUR_ROBOT_IP>
dimos run unitree-go2

Featured Runfiles

Run command	What it does
`dimos --replay run unitree-go2`	Quadruped navigation replay — SLAM, costmap, A* planning
`dimos --replay --replay-dir unitree_go2_office_walk2 run unitree-go2-temporal-memory`	Quadruped temporal memory replay
`dimos --simulation run unitree-go2-agentic-mcp`	Quadruped agentic + MCP server in simulation
`dimos --simulation run unitree-g1`	Humanoid in MuJoCo simulation
`dimos --replay run drone-basic`	Drone video + telemetry replay
`dimos --replay run drone-agentic`	Drone + LLM agent with flight skills (replay)
`dimos run demo-camera`	Webcam demo — no hardware needed
`dimos run keyboard-teleop-xarm7`	Keyboard teleop with mock xArm7 (requires `dimos[manipulation]` extra)
`dimos --simulation run unitree-go2-agentic-ollama`	Quadruped agentic with local LLM (requires Ollama + `ollama serve`)

Full blueprint docs: docs/usage/blueprints.md

Agent CLI and MCP

The dimos CLI manages the full lifecycle — run blueprints, inspect state, interact with agents, and call skills via MCP.

dimos run unitree-go2-agentic-mcp --daemon   # Start in background
dimos status                              # Check what's running
dimos log -f                              # Follow logs
dimos agent-send "explore the room"       # Send agent a command
dimos mcp list-tools                      # List available MCP skills
dimos mcp call relative_move --arg forward=0.5  # Call a skill directly
dimos stop                                # Shut down

Full CLI reference: docs/usage/cli.md

Usage

Use DimOS as a Library

See below a simple robot connection module that sends streams of continuous cmd_vel to the robot and receives color_image to a simple Listener module. DimOS Modules are subsystems on a robot that communicate with other modules using standardized messages.

import threading, time, numpy as np
from dimos.core.blueprints import autoconnect
from dimos.core.core import rpc
from dimos.core.module import Module
from dimos.core.stream import In, Out
from dimos.msgs.geometry_msgs import Twist
from dimos.msgs.sensor_msgs import Image, ImageFormat

class RobotConnection(Module):
    cmd_vel: In[Twist]
    color_image: Out[Image]

    @rpc
    def start(self):
        threading.Thread(target=self._image_loop, daemon=True).start()

    def _image_loop(self):
        while True:
            img = Image.from_numpy(
                np.zeros((120, 160, 3), np.uint8),
                format=ImageFormat.RGB,
                frame_id="camera_optical",
            )
            self.color_image.publish(img)
            time.sleep(0.2)

class Listener(Module):
    color_image: In[Image]

    @rpc
    def start(self):
        self.color_image.subscribe(lambda img: print(f"image {img.width}x{img.height}"))

if __name__ == "__main__":
    autoconnect(
        RobotConnection.blueprint(),
        Listener.blueprint(),
    ).build().loop()

Blueprints

Blueprints are instructions for how to construct and wire modules. We compose them with autoconnect(...), which connects streams by (name, type) and returns a Blueprint.

Blueprints can be composed, remapped, and have transports overridden if autoconnect() fails due to conflicting variable names or In[] and Out[] message types.

A blueprint example that connects the image stream from a robot to an LLM Agent for reasoning and action execution.

from dimos.core.blueprints import autoconnect
from dimos.core.transport import LCMTransport
from dimos.msgs.sensor_msgs import Image
from dimos.robot.unitree.go2.connection import go2_connection
from dimos.agents.agent import agent

blueprint = autoconnect(
    go2_connection(),
    agent(),
).transports({("color_image", Image): LCMTransport("/color_image", Image)})

# Run the blueprint
if __name__ == "__main__":
    blueprint.build().loop()

Library API

Demos

Development

Develop on DimOS

export GIT_LFS_SKIP_SMUDGE=1
git clone -b dev https://github.com/dimensionalOS/dimos.git
cd dimos

uv sync --all-extras --no-extra dds

# Run fast test suite
uv run pytest dimos

Multi Language Support

Python is our glue and prototyping language, but we support many languages via LCM interop.

Check our language interop examples:

ROMA

Sun, 14 Sep 2025 15:24:50 +0800

sentient-agi/ROMA

ROMA: Recursive Open Meta-Agents

Building hierarchical high-performance multi-agent systems made easy! (Beta)

Technical Blog • Paper (Coming soon) • Build Agents for $$$

📖 Documentation

🚀 Introduction - Understand the vision and architecture behind ROMA
📦 Setup - Detailed configuration options and environment setup
🤖 Agents Guide - Learn how to create and customize your own agents
⚙️ Configuration - Detailed configuration options and environment setup
🗺️ Roadmap - See what’s coming next for ROMA

🎯 What is ROMA?

ROMA is a meta-agent framework that uses recursive hierarchical structures to solve complex problems. By breaking down tasks into parallelizable components, ROMA enables agents to tackle sophisticated reasoning challenges while maintaining transparency that makes context-engineering and iteration straightforward. The framework offers parallel problem solving where agents work simultaneously on different parts of complex tasks, transparent development with a clear structure for easy debugging, and proven performance demonstrated through our search agent’s strong benchmark results. We’ve shown the framework’s effectiveness, but this is just the beginning. As an open-source and extensible platform, ROMA is designed for community-driven development, allowing you to build and customize agents for your specific needs while benefiting from the collective improvements of the community.

🏗️ How It Works

ROMA framework processes tasks through a recursive plan–execute loop:

def solve(task):
    if is_atomic(task):                 # Step 1: Atomizer
        return execute(task)            # Step 2: Executor
    else:
        subtasks = plan(task)           # Step 2: Planner
        results = []
        for subtask in subtasks:
            results.append(solve(subtask))  # Recursive call
        return aggregate(results)       # Step 3: Aggregator

# Entry point:
answer = solve(initial_request)

Atomizer – Decides whether a request is atomic (directly executable) or requires planning.
Planner – If planning is needed, the task is broken into smaller subtasks. Each subtask is fed back into the Atomizer, making the process recursive.
Executors – Handle atomic tasks. Executors can be LLMs, APIs, or even other agents — as long as they implement an agent.execute() interface.
Aggregator – Collects and integrates results from subtasks. Importantly, the Aggregator produces the answer to the original parent task, not just raw child outputs.

📐 Information Flow

Top-down: Tasks are decomposed into subtasks recursively.
Bottom-up: Subtask results are aggregated upwards into solutions for parent tasks.
Left-to-right: If a subtask depends on the output of a previous one, it waits until that subtask completes before execution.

This structure makes the system flexible, recursive, and dependency-aware — capable of decomposing complex problems into smaller steps while ensuring results are integrated coherently.

Click to view the system flow diagram

  flowchart TB
    A[Your Request] --> B{Atomizer}
    B -->|Plan Needed| C[Planner]
    B -->|Atomic Task| D[Executor]

    %% Planner spawns subtasks
    C --> E[Subtasks]
    E --> G[Aggregator]

    %% Recursion
    E -.-> B  

    %% Execution + Aggregation
    D --> F[Final Result]
    G --> F

    style A fill:#e1f5fe
    style F fill:#c8e6c9
    style B fill:#fff3e0
    style C fill:#ffe0b2
    style D fill:#d1c4e9
    style G fill:#c5cae9

🚀 30-Second Quick Start

git clone https://github.com/sentient-agi/ROMA.git
cd ROMA

# Run the automated setup
./setup.sh

Choose between:

Docker Setup (Recommended) - One-command setup with isolation
Native Setup - Direct installation for development

🛠️ Technical Stack

Framework: Built on AgnoAgents
Backend: Python 3.12+ with FastAPI/Flask
Frontend: React + TypeScript with real-time WebSocket
LLM Support: Any provider via LiteLLM
Data Persistence: Enterprise S3 mounting with security validation
- 🔒 goofys FUSE mounting for zero-latency file access
- 🛡️ Path injection protection with comprehensive validation
- 🔐 AWS credentials verification before operations
- 📁 Dynamic Docker Compose with secure volume mounting
Code Execution: E2B sandboxes with unified S3 integration
Security: Production-grade validation and error handling
Features: Multi-modal, tools, MCP, hooks, caching

📦 Installation Options

Quick Start (Recommended)

# Main setup (choose Docker or Native)
./setup.sh

# Optional: Setup E2B sandbox integration
./setup.sh --e2b

# Test E2B integration  
./setup.sh --test-e2b

Command Line Options

./setup.sh --docker     # Run Docker setup directly
./setup.sh --docker-from-scratch  # Rebuild Docker images/containers from scratch (down -v, no cache)
./setup.sh --native     # Run native setup directly (macOS/Ubuntu/Debian)
./setup.sh --e2b        # Setup E2B template (requires E2B_API_KEY + AWS creds)
./setup.sh --test-e2b   # Test E2B template integration
./setup.sh --help       # Show all available options

Manual Installation

See setup docs for detailed instructions.

🏗️ Optional: E2B Sandbox Integration

For secure code execution capabilities, optionally set up E2B sandboxes:

# After main setup, configure E2B (requires E2B_API_KEY and AWS credentials in .env)
./setup.sh --e2b

# Test E2B integration
./setup.sh --test-e2b

E2B Features:

🔒 Secure Code Execution - Run untrusted code in isolated sandboxes
☁️ S3 Integration - Automatic data sync between local and sandbox environments
🚀 goofys Mounting - High-performance S3 filesystem mounting
🔧 AWS Credentials - Passed securely via Docker build arguments

🤖 Pre-built Agents

Note: These agents are demonstrations built using ROMA’s framework through simple vibe-prompting and minimal manual tuning. They showcase how easily you can create high-performance agents with ROMA, rather than being production-final solutions. Our mission is to empower the community to build, share, and get rewarded for creating innovative agent recipes and use-cases.

ROMA comes with example agents that demonstrate the framework’s capabilities:

🔍 General Task Solver

A versatile agent powered by ChatGPT Search Preview for handling diverse tasks:

Intelligent Search: Leverages OpenAI’s latest search capabilities for real-time information
Flexible Planning: Adapts task decomposition based on query complexity
Multi-Domain: Handles everything from technical questions to creative projects
Quick Prototyping: Perfect for testing ROMA’s capabilities without domain-specific setup

Perfect for: General research, fact-checking, exploratory analysis, quick information gathering

🔬 Deep Research Agent

A comprehensive research system that breaks down complex research questions into manageable sub-tasks:

Smart Task Decomposition: Automatically splits research topics into search, analysis, and synthesis phases
Parallel Information Gathering: Executes multiple searches simultaneously for faster results
Multi-Source Integration: Combines results from web search, Wikipedia, and specialized APIs
Intelligent Synthesis: Aggregates findings into coherent, well-structured reports

Perfect for: Academic research, market analysis, competitive intelligence, technical documentation

💹 Crypto Analytics Agent

Specialized financial analysis agent with deep blockchain and DeFi expertise:

Real-Time Market Data: Integrates with Binance, CoinGecko, and DefiLlama APIs
On-Chain Analytics: Access to Arkham Intelligence for wallet tracking and token flows
Technical Analysis: Advanced charting with OHLC data and market indicators
DeFi Metrics: TVL tracking, yield analysis, protocol comparisons
Secure Execution: Runs analysis in E2B sandboxes with data persistence

Perfect for: Token research, portfolio analysis, DeFi protocol evaluation, market trend analysis

All three agents demonstrate ROMA’s recursive architecture in action, showing how complex queries that would overwhelm single-pass systems can be elegantly decomposed and solved. They serve as templates and inspiration for building your own specialized agents.

Your First Agent in 5 Minutes

`1`	`./setup.sh # Automated setup with Docker or native installation`

Access all the pre-defined agents through the frontend on localhost:3000 after setting up the backend on localhost:5000. Please checkout Setup and the Agents guide to get started!

# Your first agent in 3 lines
from sentientresearchagent import SentientAgent

agent = SentientAgent.create()
result = await agent.run("Create a podcast about AI safety")

📊 Benchmarks

We evaluate our simple implementation of a search system using ROMA, called ROMA-Search across three benchmarks: SEAL-0, FRAMES, and SimpleQA.
Below are the performance graphs for each benchmark.

SEAL-0

SealQA is a new challenging benchmark for evaluating Search-Augmented Language models on fact-seeking questions where web search yields conflicting, noisy, or unhelpful results.

FRAMES

View full results

A comprehensive evaluation dataset designed to test the capabilities of Retrieval-Augmented Generation (RAG) systems across factuality, retrieval accuracy, and reasoning.

SimpleQA

View full results

Factuality benchmark that measures the ability for language models to answer short, fact-seeking questions.

✨ Features

🔄 Recursive Task Decomposition

Automatically breaks down complex tasks into manageable subtasks with intelligent dependency management. Runs independent sub-tasks in parallel.

🤖 Agent Agnostic

Works with any provider (OpenAI, Anthropic, Google, local models) through unified interface, as long as it has an agent.run() command, then you can use it!

🔍 Complete Transparency

Stage tracing shows exactly what happens at each step - debug and optimize with full visibility

🔌 Connect Any Tool

Seamlessly integrate external tools and protocols with configurable intervention points. Already includes production-grade connectors such as E2B, file-read-write, and more.

🙏 Acknowledgments

This framework would not have been possible if it wasn’t for these amazing open-source contributions!

Inspired by the hierarchical planning approach described in “Beyond Outlining: Heterogeneous Recursive Planning” by Xiong et al.
Pydantic - Data validation using Python type annotations
Agno - Framework for building AI agents
E2B - Cloud runtime for AI agents

📚 Citation

If you use the ROMA repo in your research, please cite:

@software{al_zubi_2025_17052592,
  author       = {Al-Zubi, Salah and
                  Nama, Baran and
                  Kaz, Arda and
                  Oh, Sewoong},
  title        = {SentientResearchAgent: A Hierarchical AI Agent
                   Framework for Research and Analysis
                  },
  month        = sep,
  year         = 2025,
  publisher    = {Zenodo},
  version      = {ROMA},
  doi          = {10.5281/zenodo.17052592},
  url          = {https://doi.org/10.5281/zenodo.17052592},
  swhid        = {swh:1:dir:69cd1552103e0333dd0c39fc4f53cb03196017ce
                   ;origin=https://doi.org/10.5281/zenodo.17052591;vi
                   sit=swh:1:snp:f50bf99634f9876adb80c027361aec9dff97
                   3433;anchor=swh:1:rel:afa7caa843ce1279f5b4b29b5d3d
                   5e3fe85edc95;path=salzubi401-ROMA-b31c382
                  },
}

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

adk-python

Sat, 09 Aug 2025 15:28:44 +0800

google/adk-python

Agent Development Kit (ADK)

An open-source, code-first Python toolkit for building, evaluating, and deploying sophisticated AI agents with flexibility and control.

Important Links: Docs, Samples, Java ADK & ADK Web.

Agent Development Kit (ADK) is a flexible and modular framework for developing and deploying AI agents. While optimized for Gemini and the Google ecosystem, ADK is model-agnostic, deployment-agnostic, and is built for compatibility with other frameworks. ADK was designed to make agent development feel more like software development, to make it easier for developers to create, deploy, and orchestrate agentic architectures that range from simple tasks to complex workflows.

✨ Key Features

Rich Tool Ecosystem: Utilize pre-built tools, custom functions, OpenAPI specs, or integrate existing tools to give agents diverse capabilities, all for tight integration with the Google ecosystem.
Code-First Development: Define agent logic, tools, and orchestration directly in Python for ultimate flexibility, testability, and versioning.
Modular Multi-Agent Systems: Design scalable applications by composing multiple specialized agents into flexible hierarchies.
Deploy Anywhere: Easily containerize and deploy agents on Cloud Run or scale seamlessly with Vertex AI Agent Engine.

🤖 Agent2Agent (A2A) Protocol and ADK Integration

For remote agent-to-agent communication, ADK integrates with the A2A protocol. See this example for how they can work together.

🚀 Installation

Stable Release (Recommended)

You can install the latest stable version of ADK using pip:

`1`	`pip install google-adk`

The release cadence is weekly.

This version is recommended for most users as it represents the most recent official release.

Development Version

Bug fixes and new features are merged into the main branch on GitHub first. If you need access to changes that haven’t been included in an official PyPI release yet, you can install directly from the main branch:

`1`	`pip install git+https://github.com/google/adk-python.git@main`

Note: The development version is built directly from the latest code commits. While it includes the newest fixes and features, it may also contain experimental changes or bugs not present in the stable release. Use it primarily for testing upcoming changes or accessing critical fixes before they are officially released.

📚 Documentation

Explore the full documentation for detailed guides on building, evaluating, and deploying agents:

Documentation

🏁 Feature Highlight

Define a single agent:

from google.adk.agents import Agent
from google.adk.tools import google_search

root_agent = Agent(
    name="search_assistant",
    model="gemini-2.0-flash", # Or your preferred Gemini model
    instruction="You are a helpful assistant. Answer user questions using Google Search when needed.",
    description="An assistant that can search the web.",
    tools=[google_search]
)

Define a multi-agent system:

Define a multi-agent system with coordinator agent, greeter agent, and task execution agent. Then ADK engine and the model will guide the agents works together to accomplish the task.

from google.adk.agents import LlmAgent, BaseAgent

# Define individual agents
greeter = LlmAgent(name="greeter", model="gemini-2.0-flash", ...)
task_executor = LlmAgent(name="task_executor", model="gemini-2.0-flash", ...)

# Create parent agent and assign children via sub_agents
coordinator = LlmAgent(
    name="Coordinator",
    model="gemini-2.0-flash",
    description="I coordinate greetings and tasks.",
    sub_agents=[ # Assign sub_agents here
        greeter,
        task_executor
    ]
)

Development UI

A built-in development UI to help you test, evaluate, debug, and showcase your agent(s).

Evaluate Agents

1
2
3

adk eval \
    samples_for_testing/hello_world \
    samples_for_testing/hello_world/hello_world_eval_set_001.evalset.json

🤝 Contributing

We welcome contributions from the community! Whether it’s bug reports, feature requests, documentation improvements, or code contributions, please see our

General contribution guideline and flow.
Then if you want to contribute code, please read Code Contributing Guidelines to get started.

Vibe Coding

If you are to develop agent via vibe coding the llms.txt and the llms-full.txt can be used as context to LLM. While the former one is a summarized one and the later one has the full information in case your LLM has big enough context window.

📄 License

This project is licensed under the Apache 2.0 License - see the LICENSE file for details.

Happy Agent Building!

learn-agentic-ai

Tue, 17 Jun 2025 15:30:43 +0800

panaversity/learn-agentic-ai

Learn Agentic AI using Dapr Agentic Cloud Ascent (DACA) Design Pattern: From Start to Scale

This repo is part of the Panaversity Certified Agentic & Robotic AI Engineer program. It covers AI-201, AI-202 and AI-301 courses.

We have Two Hunches, the future of Pakistan depends on it, let’s make sure that we are not wrong:

It is very important for Pakistan that we bet on the right horses for the upcoming age of Agentic AI. We will be training millions of Agentic AI Developers all over Pakistan and online around the world and building startups, we cant afford to be wrong.

Hunch #1: Dapr We feel Dapr, Dapr Actors, Dapr Workflows, and Dapr Agents will be the core technology in building the next generation multi ai agentic systems, is my hunch correct?

Hunch #2: OpenAI Agents SDK We also have a hunch that OpenAI Agents SDK will be the go to framework for beginners to start learning Agentic AI?

Let us see what the best AI has to say about our hunches:

https://chatgpt.com/share/6811b893-82cc-8001-9037-e45bcd91cc64

https://g.co/gemini/share/1f31c876520b

https://grok.com/share/bGVnYWN5_4343d342-c7df-4b06-9174-487a64f59d53

This Panaversity Initiative Tackles the Critical Challenge:

“How do we design AI Agents that can handle 10 million concurrent AI Agents without failing?”

Note: The challenge is intensified as we must guide our students to solve this issue with minimal financial resources available during training.

Kubernetes with Dapr can theoretically handle 10 million concurrent agents in an agentic AI system without failing, but achieving this requires extensive optimization, significant infrastructure, and careful engineering. While direct evidence at this scale is limited, logical extrapolation from existing benchmarks, Kubernetes’ scalability, and Dapr’s actor model supports feasibility, especially with rigorous tuning and resource allocation.

Condensed Argument with Proof and Logic:

Kubernetes Scalability:
- Evidence: Kubernetes supports up to 5,000 nodes and 150,000 pods per cluster (Kubernetes docs), with real-world examples like PayPal scaling to 4,000 nodes and 200,000 pods (InfoQ, 2023) and KubeEdge managing 100,000 edge nodes and 1 million pods (KubeEdge case studies). OpenAI’s 2,500-node cluster for AI workloads (OpenAI blog, 2022) shows Kubernetes can handle compute-intensive tasks.
- Logic: For 10 million users, a cluster of 5,000–10,000 nodes (e.g., AWS g5 instances with GPUs) can distribute workloads. Each node can run hundreds of pods, and Kubernetes’ horizontal pod autoscaling (HPA) dynamically adjusts to demand. Bottlenecks (e.g., API server, networking) can be mitigated by tuning etcd, using high-performance CNIs like Cilium, and optimizing DNS.
Dapr’s Efficiency for Agentic AI:
- Evidence: Dapr’s actor model supports thousands of virtual actors per CPU core with double-digit millisecond latency (Dapr docs, 2024). Case studies show Dapr handling millions of events, e.g., Tempestive’s IoT platform processing billions of messages (Dapr blog, 2023) and DeFacto’s system managing 3,700 events/second (320 million daily) on Kubernetes with Kafka (Microsoft case study, 2022).
- Logic: Agentic AI relies on stateful, low-latency agents. Dapr Agents, built on the actor model, can represent 10 million users as actors, distributed across a Kubernetes cluster. Dapr’s state management (e.g., Redis) and pub/sub messaging (e.g., Kafka) ensure efficient coordination and resilience, with automatic retries preventing failures. Sharding state stores and message brokers scales to millions of operations/second.
Handling AI Workloads:
- Evidence: LLM inference frameworks like vLLM and TGI serve thousands of requests/second per GPU (vLLM benchmarks, 2024). Kubernetes orchestrates GPU workloads effectively, as seen Kubernetes manages GPU workloads, as seen in NVIDIA’s AI platform scaling to thousands of GPUs (NVIDIA case study, 2023).
- Logic: Assuming each user generates 1 request/second requiring 0.01 GPU, 10 million users need ~100,000 GPUs. Batching, caching, and model parallelism reduce this to a feasible ~10,000–20,000 GPUs, achievable in hyperscale clouds (e.g., AWS). Kubernetes’ resource scheduling ensures optimal GPU utilization.
Networking and Storage:
- Evidence: EMQX on Kubernetes handled 1 million concurrent connections with tuning (EMQX blog, 2024). C10M benchmarks (2013) achieved 10 million connections using optimized stacks. Dapr’s state stores (e.g., Redis) support millions of operations/second (Redis benchmarks, 2024).
- Logic: 10 million connections require ~100–1,000 Gbps bandwidth, supported by modern clouds. High-throughput databases (e.g., CockroachDB) and caching (e.g., Redis Cluster) handle 10 TB of state data for 10 million users (1 KB/user). Kernel bypass (e.g., DPDK) and eBPF-based CNIs (e.g., Cilium) minimize networking latency.
Resilience and Monitoring:
- Evidence: Dapr’s resiliency policies (retries, circuit breakers) and Kubernetes’ self-healing (pod restarts) ensure reliability (Dapr docs, 2024). Dapr’s OpenTelemetry integration scales monitoring for millions of agents (Prometheus case studies, 2023).
- Logic: Real-time metrics (e.g., latency, error rates) and distributed tracing prevent cascading failures. Kubernetes’ liveness probes and Dapr’s workflow engine recover from crashes, ensuring 99.999% uptime.

Feasibility with Constraints:

Challenge: No direct benchmark exists for 10 million concurrent users with Dapr/Kubernetes in an agentic AI context. Infrastructure costs (e.g., $10M–$100M for 10,000 nodes) are prohibitive for low-budget scenarios.
Solution: Use open-source tools (e.g., Minikube, kind) for local testing and cloud credits (e.g., AWS Educate) for students. Simulate 10 million users with tools like Locust on smaller clusters (e.g., 100 nodes), extrapolating results. Optimize Dapr’s actor placement and Kubernetes’ resource quotas to maximize efficiency on limited hardware. Leverage free-tier databases (e.g., MongoDB Atlas) and message brokers (e.g., RabbitMQ).

Conclusion: Kubernetes with Dapr can handle 10 million concurrent users in an agentic AI system, supported by their proven scalability, real-world case studies, and logical extrapolation. For students with minimal budgets, small-scale simulations, open-source tools, and cloud credits make the problem tractable, though production-scale deployment requires hyperscale resources and expertise.

Agentic AI Top Trend of 2025

The Dapr Agentic Cloud Ascent (DACA) Design Pattern Addresses 10 Million AI Agents Challenge

Let’s understand and learn about “Dapr Agentic Cloud Ascent (DACA)”, our winning design pattern for developing and deploying planet scale multi-agent systems.

Executive Summary: Dapr Agentic Cloud Ascent (DACA)

The Dapr Agentic Cloud Ascent (DACA) guide introduces a strategic design pattern for building and deploying sophisticated, scalable, and resilient agentic AI systems. Addressing the complexities of modern AI development, DACA integrates the OpenAI Agents SDK for core agent logic with the Model Context Protocol (MCP) for standardized tool use and the Agent2Agent (A2A) protocol for seamless inter-agent communication, all underpinned by the distributed capabilities of Dapr. Grounded in AI-first and cloud-first principles, DACA promotes the use of stateless, containerized applications deployed on platforms like Azure Container Apps (Serverless Containers) or Kubernetes, enabling efficient scaling from local development to planetary-scale production, potentially leveraging free-tier cloud services and self-hosted LLMs for cost optimization. The pattern emphasizes modularity, context-awareness, and standardized communication, envisioning an Agentia World where diverse AI agents collaborate intelligently. Ultimately, DACA offers a robust, flexible, and cost-effective framework for developers and architects aiming to create complex, cloud-native agentic AI applications that are built for scalability and resilience from the ground up.

Comprehensive Guide to Dapr Agentic Cloud Ascent (DACA) Design Pattern

Target User

Agentic AI Developer and AgentOps Professionals

Why OpenAI Agents SDK should be the main framework for agentic development for most use cases?

Table 1: Comparison of Abstraction Levels in AI Agent Frameworks

Framework	Abstraction Level	Key Characteristics	Learning Curve	Control Level	Simplicity
OpenAI Agents SDK	Minimal	Python-first, core primitives (Agents, Handoffs, Guardrails), direct control	Low	High	High
CrewAI	Moderate	Role-based agents, crews, tasks, focus on collaboration	Low-Medium	Medium	Medium
AutoGen	High	Conversational agents, flexible conversation patterns, human-in-the-loop support	Medium	Medium	Medium
Google ADK	Moderate	Multi-agent hierarchies, Google Cloud integration (Gemini, Vertex AI), rich tool ecosystem, bidirectional streaming	Medium	Medium-High	Medium
LangGraph	Low-Moderate	Graph-based workflows, nodes, edges, explicit state management	Very High	Very High	Low
Dapr Agents	Moderate	Stateful virtual actors, event-driven multi-agent workflows, Kubernetes integration, 50+ data connectors, built-in resiliency	Medium	Medium-High	Medium

The table clearly identifies why OpenAI Agents SDK should be the main framework for agentic development for most use cases:

It excels in simplicity and ease of use, making it the best choice for rapid development and broad accessibility.
It offers high control with minimal abstraction, providing the flexibility needed for agentic development without the complexity of frameworks like LangGraph.
It outperforms most alternatives (CrewAI, AutoGen, Google ADK, Dapr Agents) in balancing usability and power, and while LangGraph offers more control, its complexity makes it less practical for general use.

If your priority is ease of use, flexibility, and quick iteration in agentic development, OpenAI Agents SDK is the clear winner based on the table. However, if your project requires enterprise-scale features (e.g., Dapr Agents) or maximum control for complex workflows (e.g., LangGraph), you might consider those alternatives despite their added complexity.

Core DACA Agentic AI Courses:

AI-201: Fundamentals of Agentic AI and DACA AI-First Development (14 weeks)

⁠Agentic & DACA Theory - 1 week
UV & ⁠OpenAI Agents SDK - 5 weeks
⁠Agentic Design Patterns - 2 weeks
⁠Memory [LangMem & mem0] 1 week
Postgres/Redis (Managed Cloud) - 1 week
FastAPI (Basic) - 2 weeks
⁠Containerization (Rancher Desktop) - 1 week
Hugging Face Docker Spaces - 1 week

AI-201 Video Playlist

Note: These videos are for additional learning, and do not cover all the material taught in the onsite classes.

Prerequisite: Successful completion of AI-101: Modern AI Python Programming - Your Launchpad into Intelligent Systems

AI-202: DACA Cloud-First Agentic AI Development (14 weeks)

Rancher Desktop with Local Kubernetes - 4 weeks
Advanced FastAPI with Kubernetes - 2 weeks
Dapr [workflows, state, pubsub, secrets] - 3 Week
CockRoachdb & RabbitMQ Managed Services - 2 weeks
⁠Model Context Protocol - 2 weeks
⁠Serverless Containers Deployment (ACA) - 2 weeks

Prerequisite: Successful completion of AI-201

AI-301 DACA Planet-Scale Distributed AI Agents (14 Weeks)

⁠Certified Kubernetes Application Developer (CKAD) - 4 weeks
⁠A2A Protocol - 2 weeks
⁠Voice Agents - 2 weeks
⁠Dapr Agents/Google ADK - 2 weeks
⁠Self-LLMs Hosting - 1 week
Finetuning LLMs - 3 weeks

Prerequisite: Successful completion of AI-201 & AI-202

Evaluations

Quizzes + Hackathons (Everything is Onsite)

Advanced Modern Python (including asyncio) [Q1]
OpenAI Agents SDK (48 MCQ in 2 hour) [01_ai_agents_first]
Protocols & Design Patterns (A2A and MCP) [05_ai_protocols]
Hackathon1 - 8 Hours (Using Above Quiz Stack)
Containerization + FastAPI [05_daca_agent_native_dev = 01 + 02 ]
Kubernetes (Rancher Desktop) [Stimulations] [05_daca_agent_native_dev = 02 ]
Dapr-1 - State, PubSub, Bindings, Invocation [05_daca_agent_native_dev = 03 ]
Dapr-2 - Workflows, Virtual Actors [04_agent_native = 04, 05, 06]
Hackathon2 - 8 Hours (Agent Native Startup)
CKAD + DAPR + ArgoCD (Simulations) [06_daca_deployment_guide + 07_ckad]

Quiz Details

Fundamentals of Agentic AI Quiz

Total Questions: 48 MCQs

Duration: 120 Minutes

Difficulty Level: Intermediate or Advanced (NOT beginner-level)

Quiz Preparation Playlist

This is a well-constructed, comprehensive quiz that accurately tests deep knowledge of the OpenAI Agents SDK. However, it’s significantly more challenging than typical beginner-level assessments.

Difficulty Level for Beginners

The quiz is challenging for beginners due to the following factors:

Technical Depth: Questions require understanding the OpenAI Agents SDK’s architecture (e.g., Agents, Tools, Handoffs, Runner), Pydantic models, async programming, and prompt engineering. These are advanced topics for someone new to AI or Python.
Conceptual Complexity: Topics like dynamic instructions, context management, error handling, and Chain-of-Thought prompting require familiarity with both theoretical and practical aspects of agentic AI.
Code Analysis: Many questions involve analyzing code snippets, understanding execution paths, and predicting outcomes, which demand strong Python and debugging skills. Domain Knowledge: Questions on Markdown are simpler, but the majority focus on niche SDK features, making the quiz specialized.
Beginner Challenges: Beginners (e.g., those with basic Python knowledge and minimal AI experience) would struggle with SDK-specific concepts like Runner.run_sync, tool_choice, and Pydantic validation, as well as async programming and multi-agent workflows.
Difficulty Rating: Advanced (not beginner-friendly). Beginners would need foundational knowledge in Python, async programming, and LLMs, plus specific training on the OpenAI Agents SDK to perform well.

To excel in this quiz, focus on understanding the core components and philosophy of the OpenAI Agents SDK, such as its “Python-first” design for orchestration, the roles of Agents and Tools, and how primitives like “Handoffs” facilitate multi-agent collaboration. Pay close attention to how the SDK manages the agent loop, handles tool calls and Pydantic models for typed inputs/outputs, and uses context objects. Review concepts like dynamic instructions, agent cloning, error handling during tool execution, and the nuances of Runner.run_sync() versus streaming. Additionally, refresh your knowledge of prompt engineering techniques, including crafting clear instructions, guiding the agent’s reasoning (e.g., Chain-of-Thought), and managing sensitive data through persona and careful prompting. Finally, ensure you’re comfortable with basic Markdown syntax for links and images.

Preparation Guide for Beginner Students

This OpenAI Agents SDK quiz is designed for intermediate to advanced learners and requires substantial preparation to succeed. Before attempting this assessment, ensure you have a solid foundation in Python programming, including object-oriented concepts, async/await patterns, decorators, and error handling. You’ll need to thoroughly study Pydantic models for data validation, understanding field definitions, default values, and validation behavior. Dedicate significant time to the OpenAI Agents SDK documentation (https://openai.github.io/openai-agents-python/), focusing on core concepts like Agents, Tools, Handoffs, context management, and the agent execution loop. Practice writing and analyzing code that uses the @function_tool decorator, Runner.run_sync(), agent cloning, and multi-agent orchestration patterns. Review prompt engineering techniques from the OpenAI cookbook, particularly Chain-of-Thought prompting, system message design, and handling sensitive data. Finally, familiarize yourself with basic Markdown syntax for links and images. Plan to spend at least 2-3 weeks studying these materials, complete hands-on coding exercises with the SDK. Consider this quiz a capstone assessment that requires comprehensive understanding rather than a beginner-level introduction to the concepts.

Quiz Covers:

https://openai.github.io/openai-agents-python/

https://cookbook.openai.com/examples/gpt4-1_prompting_guide

https://www.markdownguide.org/basic-syntax/

https://www.markdownguide.org/cheat-sheet/

https://github.com/panaversity/learn-agentic-ai/tree/main/01_ai_agents_first

You Can Generate Mock Quizzes for Practice using LLMs from this Prompt:

Create a comprehensive quiz covering OpenAI Agents SDK. It should include as many MCQ Quiz Questions as required to test the material, the questions should be difficult and at the graduate level and should test both concepts and include code were required. From the following following documentation:

https://openai.github.io/openai-agents-python/

semantic-kernel

Thu, 22 May 2025 15:29:12 +0800

microsoft/semantic-kernel

Semantic Kernel

Build intelligent AI agents and multi-agent systems with this enterprise-ready orchestration framework

What is Semantic Kernel?

Semantic Kernel is a model-agnostic SDK that empowers developers to build, orchestrate, and deploy AI agents and multi-agent systems. Whether you’re building a simple chatbot or a complex multi-agent workflow, Semantic Kernel provides the tools you need with enterprise-grade reliability and flexibility.

System Requirements

Python: 3.10+
.NET: .NET 8.0+
Java: JDK 17+
OS Support: Windows, macOS, Linux

Key Features

Model Flexibility: Connect to any LLM with built-in support for OpenAI, Azure OpenAI, Hugging Face, NVidia and more
Agent Framework: Build modular AI agents with access to tools/plugins, memory, and planning capabilities
Multi-Agent Systems: Orchestrate complex workflows with collaborating specialist agents
Plugin Ecosystem: Extend with native code functions, prompt templates, OpenAPI specs, or Model Context Protocol (MCP)
Vector DB Support: Seamless integration with Azure AI Search, Elasticsearch, Chroma, and more
Multimodal Support: Process text, vision, and audio inputs
Local Deployment: Run with Ollama, LMStudio, or ONNX
Process Framework: Model complex business processes with a structured workflow approach
Enterprise Ready: Built for observability, security, and stable APIs

Installation

First, set the environment variable for your AI Services:

Azure OpenAI:

`1`	`export AZURE_OPENAI_API_KEY=AAA....`

or OpenAI directly:

`1`	`export OPENAI_API_KEY=sk-...`

Python

`1`	`pip install semantic-kernel`

.NET

1
2

dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.SemanticKernel.Agents.core

Java

See semantic-kernel-java build for instructions.

Quickstart

Basic Agent - Python

Create a simple assistant that responds to user prompts:

import asyncio
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

async def main():
    # Initialize a chat agent with basic instructions
    agent = ChatCompletionAgent(
        service=AzureChatCompletion(),
        name="SK-Assistant",
        instructions="You are a helpful assistant.",
    )

    # Get a response to a user message
    response = await agent.get_response(messages="Write a haiku about Semantic Kernel.")
    print(response.content)

asyncio.run(main()) 

# Output:
# Language's essence,
# Semantic threads intertwine,
# Meaning's core revealed.

Basic Agent - .NET

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;

var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion(
                Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT"),
                Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT"),
                Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")
                );
var kernel = builder.Build();

ChatCompletionAgent agent =
    new()
    {
        Name = "SK-Agent",
        Instructions = "You are a helpful assistant.",
        Kernel = kernel,
    };

await foreach (AgentResponseItem<ChatMessageContent> response 
    in agent.InvokeAsync("Write a haiku about Semantic Kernel."))
{
    Console.WriteLine(response.Message);
}

// Output:
// Language's essence,
// Semantic threads intertwine,
// Meaning's core revealed.

Agent with Plugins - Python

Enhance your agent with custom tools (plugins) and structured output:

import asyncio
from typing import Annotated
from pydantic import BaseModel
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, OpenAIChatPromptExecutionSettings
from semantic_kernel.functions import kernel_function, KernelArguments

class MenuPlugin:
    @kernel_function(description="Provides a list of specials from the menu.")
    def get_specials(self) -> Annotated[str, "Returns the specials from the menu."]:
        return """
        Special Soup: Clam Chowder
        Special Salad: Cobb Salad
        Special Drink: Chai Tea
        """

    @kernel_function(description="Provides the price of the requested menu item.")
    def get_item_price(
        self, menu_item: Annotated[str, "The name of the menu item."]
    ) -> Annotated[str, "Returns the price of the menu item."]:
        return "$9.99"

class MenuItem(BaseModel):
    price: float
    name: str

async def main():
    # Configure structured output format
    settings = OpenAIChatPromptExecutionSettings()
    settings.response_format = MenuItem

    # Create agent with plugin and settings
    agent = ChatCompletionAgent(
        service=AzureChatCompletion(),
        name="SK-Assistant",
        instructions="You are a helpful assistant.",
        plugins=[MenuPlugin()],
        arguments=KernelArguments(settings)
    )

    response = await agent.get_response(messages="What is the price of the soup special?")
    print(response.content)

    # Output:
    # The price of the Clam Chowder, which is the soup special, is $9.99.

asyncio.run(main())

Agent with Plugin - .NET

using System.ComponentModel;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
using Microsoft.SemanticKernel.ChatCompletion;

var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion(
                Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT"),
                Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT"),
                Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")
                );
var kernel = builder.Build();

kernel.Plugins.Add(KernelPluginFactory.CreateFromType<MenuPlugin>());

ChatCompletionAgent agent =
    new()
    {
        Name = "SK-Assistant",
        Instructions = "You are a helpful assistant.",
        Kernel = kernel,
        Arguments = new KernelArguments(new PromptExecutionSettings() { FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() })

    };

await foreach (AgentResponseItem<ChatMessageContent> response 
    in agent.InvokeAsync("What is the price of the soup special?"))
{
    Console.WriteLine(response.Message);
}

sealed class MenuPlugin
{
    [KernelFunction, Description("Provides a list of specials from the menu.")]
    public string GetSpecials() =>
        """
        Special Soup: Clam Chowder
        Special Salad: Cobb Salad
        Special Drink: Chai Tea
        """;

    [KernelFunction, Description("Provides the price of the requested menu item.")]
    public string GetItemPrice(
        [Description("The name of the menu item.")]
        string menuItem) =>
        "$9.99";
}

Multi-Agent System - Python

Build a system of specialized agents that can collaborate:

import asyncio
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, OpenAIChatCompletion

billing_agent = ChatCompletionAgent(
    service=AzureChatCompletion(), 
    name="BillingAgent", 
    instructions="You handle billing issues like charges, payment methods, cycles, fees, discrepancies, and payment failures."
)

refund_agent = ChatCompletionAgent(
    service=AzureChatCompletion(),
    name="RefundAgent",
    instructions="Assist users with refund inquiries, including eligibility, policies, processing, and status updates.",
)

triage_agent = ChatCompletionAgent(
    service=OpenAIChatCompletion(),
    name="TriageAgent",
    instructions="Evaluate user requests and forward them to BillingAgent or RefundAgent for targeted assistance."
    " Provide the full answer to the user containing any information from the agents",
    plugins=[billing_agent, refund_agent],
)

thread: None

async def main() -> None:
    print("Welcome to the chat bot!\n  Type 'exit' to exit.\n  Try to get some billing or refund help.")
    while True:
        user_input = input("User:> ")

        if user_input.lower().strip() == "exit":
            print("\n\nExiting chat...")
            return False

        response = await triage_agent.get_response(
            messages=user_input,
            thread=thread,
        )

        if response:
            print(f"Agent :> {response}")

# Agent :> I understand that you were charged twice for your subscription last month, and I'm here to assist you with resolving this issue. Here’s what we need to do next:

# 1. **Billing Inquiry**:
#    - Please provide the email address or account number associated with your subscription, the date(s) of the charges, and the amount charged. This will allow the billing team to investigate the discrepancy in the charges.

# 2. **Refund Process**:
#    - For the refund, please confirm your subscription type and the email address associated with your account.
#    - Provide the dates and transaction IDs for the charges you believe were duplicated.

# Once we have these details, we will be able to:

# - Check your billing history for any discrepancies.
# - Confirm any duplicate charges.
# - Initiate a refund for the duplicate payment if it qualifies. The refund process usually takes 5-10 business days after approval.

# Please provide the necessary details so we can proceed with resolving this issue for you.


if __name__ == "__main__":
    asyncio.run(main())

Where to Go Next

📖 Try our Getting Started Guide or learn about Building Agents
🔌 Explore over 100 Detailed Samples
💡 Learn about core Semantic Kernel Concepts

API References

Troubleshooting

Common Issues

Authentication Errors: Check that your API key environment variables are correctly set
Model Availability: Verify your Azure OpenAI deployment or OpenAI model access

Getting Help

Check our GitHub issues for known problems
Search the Discord community for solutions
Include your SDK version and full error messages when asking for help

Join the community

We welcome your contributions and suggestions to the SK community! One of the easiest ways to participate is to engage in discussions in the GitHub repository. Bug reports and fixes are welcome!

For new features, components, or extensions, please open an issue and discuss with us before sending a PR. This is to avoid rejection as we might be taking the core in a different direction, but also to consider the impact on the larger ecosystem.

To learn more and get started:

Read the documentation
Learn how to contribute to the project
Ask questions in the GitHub discussions
Ask questions in the Discord community
Attend regular office hours and SK community events
Follow the team on our blog

Contributor Wall of Fame

Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

License

Licensed under the MIT license.

Multi-Agent Systems on Producthunt daily

dimos

The Agentive Operating System for Physical Space

Intro

Perception

Spatial Memory

Hardware

Quadruped

Humanoid

Arm

Drone

Misc

Installation

Interactive Install

Manual System Install

Python Install

Quickstart

Featured Runfiles

Agent CLI and MCP

Usage

Use DimOS as a Library

Blueprints

Library API

Demos

Development

Develop on DimOS

Multi Language Support

ROMA

ROMA: Recursive Open Meta-Agents

📖 Documentation

🎯 What is ROMA?

🏗️ How It Works

📐 Information Flow

🚀 30-Second Quick Start

🛠️ Technical Stack

📦 Installation Options

Quick Start (Recommended)

Command Line Options

Manual Installation

🏗️ Optional: E2B Sandbox Integration

🤖 Pre-built Agents

🔍 General Task Solver

🔬 Deep Research Agent

💹 Crypto Analytics Agent

Your First Agent in 5 Minutes

📊 Benchmarks

✨ Features

🔄 Recursive Task Decomposition

🤖 Agent Agnostic

🔍 Complete Transparency

🔌 Connect Any Tool

🙏 Acknowledgments

📚 Citation

📄 License

adk-python

Agent Development Kit (ADK)

An open-source, code-first Python toolkit for building, evaluating, and deploying sophisticated AI agents with flexibility and control.

Important Links: Docs, Samples, Java ADK & ADK Web.

✨ Key Features

🤖 Agent2Agent (A2A) Protocol and ADK Integration

🚀 Installation

Stable Release (Recommended)

Development Version

📚 Documentation

🏁 Feature Highlight

Define a single agent:

Define a multi-agent system:

Development UI

Evaluate Agents

🤝 Contributing

Vibe Coding

📄 License

learn-agentic-ai

Learn Agentic AI using Dapr Agentic Cloud Ascent (DACA) Design Pattern: From Start to Scale

This Panaversity Initiative Tackles the Critical Challenge:

The Dapr Agentic Cloud Ascent (DACA) Design Pattern Addresses 10 Million AI Agents Challenge

Executive Summary: Dapr Agentic Cloud Ascent (DACA)

Target User

Why OpenAI Agents SDK should be the main framework for agentic development for most use cases?

Core DACA Agentic AI Courses: