agno 2.3.20__py3-none-any.whl → 2.3.22__py3-none-any.whl

agno/workflow/remote.py

@@ -24,21 +24,28 @@ class RemoteWorkflow(BaseRemote):
         base_url: str,
         workflow_id: str,
         timeout: float = 300.0,
+        protocol: Literal["agentos", "a2a"] = "agentos",
+        a2a_protocol: Literal["json-rpc", "rest"] = "rest",
         config_ttl: float = 300.0,
     ):
-        """Initialize AgentOSRunner for local or remote execution.
+        """Initialize RemoteWorkflow for remote execution.
 
-        For remote execution, provide base_url and workflow_id.
+        Supports two protocols:
+        - "agentos": Agno's proprietary AgentOS REST API (default)
+        - "a2a": A2A (Agent-to-Agent) protocol for cross-framework communication
 
         Args:
-            base_url: Base URL for remote AgentOS instance (e.g., "http://localhost:7777")
-            workflow_id: ID of remote workflow
+            base_url: Base URL for remote instance (e.g., "http://localhost:7777")
+            workflow_id: ID of remote workflow on the remote server
             timeout: Request timeout in seconds (default: 300)
+            protocol: Communication protocol - "agentos" (default) or "a2a"
+            a2a_protocol: For A2A protocol only - Whether to use JSON-RPC or REST protocol.
             config_ttl: Time-to-live for cached config in seconds (default: 300)
         """
-        super().__init__(base_url, timeout, config_ttl)
+        super().__init__(base_url, timeout, protocol, a2a_protocol, config_ttl)
         self.workflow_id = workflow_id
         self._cached_workflow_config = None
+        self._config_ttl = config_ttl
 
     @property
     def id(self) -> str:
@@ -46,13 +53,38 @@ class RemoteWorkflow(BaseRemote):
 
     async def get_workflow_config(self) -> "WorkflowResponse":
         """Get the workflow config from remote (always fetches fresh)."""
-        return await self.client.aget_workflow(self.workflow_id)
+        from agno.os.routers.workflows.schema import WorkflowResponse
+
+        if self.protocol == "a2a":
+            from agno.client.a2a.schemas import AgentCard
+
+            agent_card: Optional[AgentCard] = await self.a2a_client.aget_agent_card()  # type: ignore
+
+            return WorkflowResponse(
+                id=self.workflow_id,
+                name=agent_card.name if agent_card else self.workflow_id,
+                description=agent_card.description if agent_card else f"A2A workflow: {self.workflow_id}",
+            )
+
+        # AgentOS protocol: fetch fresh config from remote
+        return await self.agentos_client.aget_workflow(self.workflow_id)  # type: ignore
 
     @property
     def _workflow_config(self) -> "WorkflowResponse":
         """Get the workflow config from remote, cached with TTL."""
         from agno.os.routers.workflows.schema import WorkflowResponse
 
+        if self.protocol == "a2a":
+            from agno.client.a2a.schemas import AgentCard
+
+            agent_card: Optional[AgentCard] = self.a2a_client.get_agent_card()  # type: ignore
+
+            return WorkflowResponse(
+                id=self.workflow_id,
+                name=agent_card.name if agent_card else self.workflow_id,
+                description=agent_card.description if agent_card else f"A2A workflow: {self.workflow_id}",
+            )
+
         current_time = time.time()
 
         # Check if cache is valid
@@ -62,15 +94,15 @@ class RemoteWorkflow(BaseRemote):
                 return config
 
         # Fetch fresh config
-        config: WorkflowResponse = self.client.get_workflow(self.workflow_id)  # type: ignore
+        config: WorkflowResponse = self.agentos_client.get_workflow(self.workflow_id)  # type: ignore
         self._cached_workflow_config = (config, current_time)
         return config
 
-    def refresh_config(self) -> "WorkflowResponse":
+    async def refresh_config(self) -> "WorkflowResponse":
         """Force refresh the cached workflow config."""
         from agno.os.routers.workflows.schema import WorkflowResponse
 
-        config: WorkflowResponse = self.client.get_workflow(self.workflow_id)
+        config: WorkflowResponse = await self.agentos_client.aget_workflow(self.workflow_id)  # type: ignore
         self._cached_workflow_config = (config, time.time())
         return config
 
@@ -88,10 +120,15 @@ class RemoteWorkflow(BaseRemote):
 
     @property
     def db(self) -> Optional[RemoteDb]:
-        if self._workflow_config is not None and self._workflow_config.db_id is not None:
+        if (
+            self.agentos_client
+            and self._config
+            and self._workflow_config is not None
+            and self._workflow_config.db_id is not None
+        ):
             return RemoteDb.from_config(
                 db_id=self._workflow_config.db_id,
-                client=self.client,
+                client=self.agentos_client,
                 config=self._config,
             )
         return None
@@ -165,41 +202,144 @@ class RemoteWorkflow(BaseRemote):
         serialized_input = serialize_input(validated_input)
         headers = self._get_auth_headers(auth_token)
 
-        if stream:
-            # Handle streaming response
-            return self.get_client().run_workflow_stream(
-                workflow_id=self.workflow_id,
+        # A2A protocol path
+        if self.a2a_client:
+            return self._arun_a2a(  # type: ignore[return-value]
                 message=serialized_input,
-                additional_data=additional_data,
-                run_id=run_id,
-                session_id=session_id,
+                stream=stream or False,
                 user_id=user_id,
-                audio=audio,
+                context_id=session_id,  # Map session_id → context_id for A2A
                 images=images,
                 videos=videos,
+                audio=audio,
                 files=files,
-                session_state=session_state,
-                stream_events=stream_events,
                 headers=headers,
-                **kwargs,
             )
+
+        # AgentOS protocol path (default)
+        if self.agentos_client:
+            if stream:
+                # Handle streaming response
+                return self.agentos_client.run_workflow_stream(
+                    workflow_id=self.workflow_id,
+                    message=serialized_input,
+                    additional_data=additional_data,
+                    run_id=run_id,
+                    session_id=session_id,
+                    user_id=user_id,
+                    audio=audio,
+                    images=images,
+                    videos=videos,
+                    files=files,
+                    session_state=session_state,
+                    stream_events=stream_events,
+                    headers=headers,
+                    **kwargs,
+                )
+            else:
+                return self.agentos_client.run_workflow(  # type: ignore
+                    workflow_id=self.workflow_id,
+                    message=serialized_input,
+                    additional_data=additional_data,
+                    run_id=run_id,
+                    session_id=session_id,
+                    user_id=user_id,
+                    audio=audio,
+                    images=images,
+                    videos=videos,
+                    files=files,
+                    session_state=session_state,
+                    headers=headers,
+                    **kwargs,
+                )
         else:
-            return self.get_client().run_workflow(  # type: ignore
-                workflow_id=self.workflow_id,
-                message=serialized_input,
-                additional_data=additional_data,
-                run_id=run_id,
-                session_id=session_id,
+            raise ValueError("No client available")
+
+    def _arun_a2a(
+        self,
+        message: str,
+        stream: bool,
+        user_id: Optional[str],
+        context_id: Optional[str],
+        images: Optional[List[Image]],
+        videos: Optional[List[Video]],
+        audio: Optional[List[Audio]],
+        files: Optional[List[File]],
+        headers: Optional[Dict[str, str]],
+    ) -> Union[WorkflowRunOutput, AsyncIterator[WorkflowRunOutputEvent]]:
+        """Execute via A2A protocol.
+
+        Args:
+            message: Serialized message string
+            stream: Whether to stream the response
+            user_id: User identifier
+            context_id: Session/context ID (maps to session_id)
+            images: Images to include
+            videos: Videos to include
+            audio: Audio files to include
+            files: Files to include
+            headers: HTTP headers to include in the request (optional)
+        Returns:
+            WorkflowRunOutput for non-streaming, AsyncIterator[WorkflowRunOutputEvent] for streaming
+        """
+        if not self.a2a_client:
+            raise ValueError("A2A client not available")
+        from agno.client.a2a.utils import map_stream_events_to_workflow_run_events
+
+        if stream:
+            # Return async generator for streaming
+            event_stream = self.a2a_client.stream_message(
+                message=message,
+                context_id=context_id,
                 user_id=user_id,
-                audio=audio,
+                images=list(images) if images else None,
+                audio=list(audio) if audio else None,
+                videos=list(videos) if videos else None,
+                files=list(files) if files else None,
+                headers=headers,
+            )
+            return map_stream_events_to_workflow_run_events(event_stream, workflow_id=self.workflow_id)  # type: ignore
+        else:
+            # Return coroutine for non-streaming
+            return self._arun_a2a_send(  # type: ignore[return-value]
+                message=message,
+                user_id=user_id,
+                context_id=context_id,
                 images=images,
+                audio=audio,
                 videos=videos,
                 files=files,
-                session_state=session_state,
                 headers=headers,
-                **kwargs,
             )
 
+    async def _arun_a2a_send(
+        self,
+        message: str,
+        user_id: Optional[str],
+        context_id: Optional[str],
+        images: Optional[List[Image]],
+        videos: Optional[List[Video]],
+        audio: Optional[List[Audio]],
+        files: Optional[List[File]],
+        headers: Optional[Dict[str, str]],
+    ) -> WorkflowRunOutput:
+        """Send a non-streaming A2A message and convert response to WorkflowRunOutput."""
+        if not self.a2a_client:
+            raise ValueError("A2A client not available")
+        from agno.client.a2a.utils import map_task_result_to_workflow_run_output
+
+        task_result = await self.a2a_client.send_message(
+            message=message,
+            context_id=context_id,
+            user_id=user_id,
+            images=list(images) if images else None,
+            audio=list(audio) if audio else None,
+            videos=list(videos) if videos else None,
+            files=list(files) if files else None,
+            headers=headers,
+        )
+        return map_task_result_to_workflow_run_output(task_result, workflow_id=self.workflow_id, user_id=user_id)
+
     async def cancel_run(self, run_id: str, auth_token: Optional[str] = None) -> bool:
         """Cancel a running workflow execution.
 
@@ -212,7 +352,7 @@ class RemoteWorkflow(BaseRemote):
         """
         headers = self._get_auth_headers(auth_token)
         try:
-            await self.get_client().cancel_workflow_run(
+            await self.get_os_client().cancel_workflow_run(
                 workflow_id=self.workflow_id,
                 run_id=run_id,
                 headers=headers,

agno/workflow/router.py

@@ -267,6 +267,7 @@ class Router:
             step_type=StepType.ROUTER,
             content=f"Router {self.name} completed with {len(all_results)} results",
             success=all(result.success for result in all_results) if all_results else True,
+            stop=any(result.stop for result in all_results) if all_results else False,
             steps=all_results,
         )
 
@@ -438,6 +439,7 @@ class Router:
             step_type=StepType.ROUTER,
             content=f"Router {self.name} completed with {len(all_results)} results",
             success=all(result.success for result in all_results) if all_results else True,
+            stop=any(result.stop for result in all_results) if all_results else False,
             steps=all_results,
         )
 
@@ -544,6 +546,7 @@ class Router:
             step_type=StepType.ROUTER,
             content=f"Router {self.name} completed with {len(all_results)} results",
             success=all(result.success for result in all_results) if all_results else True,
+            stop=any(result.stop for result in all_results) if all_results else False,
             steps=all_results,
         )
 
@@ -718,6 +721,6 @@ class Router:
             content=f"Router {self.name} completed with {len(all_results)} results",
             success=all(result.success for result in all_results) if all_results else True,
             error=None,
-            stop=False,
+            stop=any(result.stop for result in all_results) if all_results else False,
             steps=all_results,
         )

agno/workflow/steps.py

@@ -194,6 +194,7 @@ class Steps:
                 step_type=StepType.STEPS,
                 content=f"Steps {self.name} completed with {len(all_results)} results",
                 success=all(result.success for result in all_results) if all_results else True,
+                stop=any(result.stop for result in all_results) if all_results else False,
                 steps=all_results,
             )
 
@@ -351,6 +352,7 @@ class Steps:
                 step_type=StepType.STEPS,
                 content=f"Steps {self.name} completed with {len(all_results)} results",
                 success=all(result.success for result in all_results) if all_results else True,
+                stop=any(result.stop for result in all_results) if all_results else False,
                 steps=all_results,
             )
 
@@ -443,6 +445,7 @@ class Steps:
                 step_type=StepType.STEPS,
                 content=f"Steps {self.name} completed with {len(all_results)} results",
                 success=all(result.success for result in all_results) if all_results else True,
+                stop=any(result.stop for result in all_results) if all_results else False,
                 steps=all_results,
             )
 
@@ -599,6 +602,7 @@ class Steps:
                 step_type=StepType.STEPS,
                 content=f"Steps {self.name} completed with {len(all_results)} results",
                 success=all(result.success for result in all_results) if all_results else True,
+                stop=any(result.stop for result in all_results) if all_results else False,
                 steps=all_results,
             )
 

{agno-2.3.20.dist-info → agno-2.3.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.3.20
+Version: 2.3.22
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com
@@ -157,7 +157,7 @@ Requires-Dist: mcp>=1.9.2; extra == "mcp"
 Provides-Extra: mem0
 Requires-Dist: mem0ai; extra == "mem0"
 Provides-Extra: memori
-Requires-Dist: memorisdk==3.0.5; extra == "memori"
+Requires-Dist: memori>=3.0.5; extra == "memori"
 Provides-Extra: newspaper
 Requires-Dist: newspaper4k; extra == "newspaper"
 Requires-Dist: lxml_html_clean; extra == "newspaper"
@@ -415,7 +415,7 @@ Dynamic: license-file
 <div align="center">
   <a href="https://docs.agno.com">Documentation</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-  <a href="https://docs.agno.com/examples/use-cases/agents/overview">Examples</a>
+  <a href="https://github.com/agno-agi/agno/tree/main/cookbook">Cookbook</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
   <a href="https://www.agno.com/?utm_source=github&utm_medium=readme&utm_campaign=agno-github">Website</a>
   <br />
@@ -423,25 +423,26 @@ Dynamic: license-file
 
 ## What is Agno?
 
-Agno is an incredibly fast multi-agent framework, runtime and control plane.
+Agno is a multi-agent framework, runtime, and control plane. Use it to build private and secure AI products that run in your cloud.
 
-Companies want to build AI products, run them securely in their cloud, and manage their agents with a beautiful UI. This takes more than calling an LLM API, it requires a thoughtfully designed agentic platform.
+- **Build** agents, teams, and workflows with memory, knowledge, guardrails and 100+ integrations.
+- **Run** in production with a stateless FastAPI runtime. Horizontally scalable.
+- **Manage** with a control plane that connects directly to your runtime — no data leaves your environment.
 
-Agno provides the unified stack for building, running and managing multi-agent systems:
+## Why Agno?
 
-- **Framework**: Build agents, multi-agent teams and workflows with memory, knowledge, state, guardrails, HITL, context compression, MCP, A2A and 100+ toolkits.
-- **AgentOS Runtime**: Run your multi-agent system in production with a secure, stateless runtime and ready to use integration endpoints.
-- **AgentOS Control Plane**: Test, monitor and manage AgentOS deployments across environments with full operational visibility.
+- **Your cloud, your data:** Runs entirely in your infrastructure. Nothing leaves your environment.
+- **Ready for production on day one:** Pre-built FastAPI runtime with SSE endpoints, ready to deploy.
+- **Incredibly fast:** 529× faster than LangGraph, 24× lower memory.
 
-Checkout the full list of features [here](#features).
+## Getting Started
 
-## Getting started
+Start with the [getting started guide](https://github.com/agno-agi/agno/tree/main/cookbook/00_getting_started), then:
 
-If you're new to Agno, follow our [quickstart](https://docs.agno.com/get-started/quickstart) to build your first Agent and chat with it using the AgentOS UI.
+- Browse the [cookbooks](https://github.com/agno-agi/agno/tree/main/cookbook) for real-world examples
+- Read the [docs](https://docs.agno.com) to learn more
 
-After that, checkout the [examples gallery](https://docs.agno.com/examples/use-cases/agents/overview) and build real-world applications with Agno.
-
-## Documentation, Community & More Examples
+## Resources
 
 - Docs: <a href="https://docs.agno.com" target="_blank" rel="noopener noreferrer">docs.agno.com</a>
 - Cookbook: <a href="https://github.com/agno-agi/agno/tree/main/cookbook" target="_blank" rel="noopener noreferrer">Cookbook</a>
@@ -497,144 +498,72 @@ When you run the example script shared above, you get a FastAPI app that you can
 
 https://github.com/user-attachments/assets/feb23db8-15cc-4e88-be7c-01a21a03ebf6
 
-## The Complete Agentic Solution
+## Private by Design
 
-Agno provides the complete solution for companies building agentic systems:
+This is the part we care most about.
 
-- The fastest framework for building agents, multi-agent teams and agentic workflows.
-- A ready-to-use FastAPI app that gets you building AI products on day one.
-- A control plane for testing, monitoring and managing your system.
+AgentOS runs in **your** cloud. The control plane UI connects directly to your runtime from your browser. Your data never touches our servers. No retention costs, no vendor lock-in, no compliance headaches.
 
-Agno brings a novel architecture that no other framework provides, your AgentOS runs securely in your cloud, and the control plane connects directly to it from your browser. You don't need to send data to any external services or pay retention costs, you get complete privacy and control.
+This isn't a privacy mode or enterprise add-on. It's how Agno works.
 
 ## Features
 
-Agno is an incredibly feature-rich framework purpose-built for Agent Engineering. Here are some key features:
-
-| **Category**                           | **Feature**                     | **Description**                                                                                                           |
-| -------------------------------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| **Foundational Principles**            | **Model Agnostic**              | Supports all model providers so you can choose the best model for your use case |
-|                                        | **Type Safe**                   | Enforces structured I/O through input_schema and output_schema for predictable and composable agent behavior. |
-|                                        | **Dynamic Context**             | Inject variables, state, and retrieved data at runtime into context. Compress, summarize and filter context to keep your Agents focused and efficient. |
-|                                        | **Designed for Scale**          | Designed around async execution and long-running tasks for high throughput agent workloads. |
-| **Memory, Knowledge, and Persistence** | **Persistent Storage**          | Give your Agents, Teams, and Workflows a database to persist session history, state, and messages. |
-|                                        | **User Memory**                 | Built in memory layer that helps agents recall user specific context across sessions. |
-|                                        | **Agentic RAG**                 | Connect to 20+ vector stores (called **Knowledge**) with hybrid search, reranking, and chunking out of the box. |
-|                                        | **Culture** | Shared long term collective memory that compounds across agents and time. |
-|                                        | **Ephemeral Context** | In memory scratchpad for short lived reasoning without polluting long term state. |
-| **Execution & Control**                | **Human-in-the-Loop**           | Native support for confirmations, approvals, manual overrides, and external actions. |
-|                                        | **Guardrails**                  | Built-in safeguards for validation, security, and prompt protection.                                                      |
-|                                        | **Agent Lifecycle Hooks**       | Pre and post hooks to validate, enrich, or transform inputs and outputs. |
-|                                        | **MCP Integration**             | First-class support for the Model Context Protocol (MCP) to connect Agents with external systems. |
-|                                        | **A2A Integration**             | First-class support for the Agent to Agent communication protocol (A2A). |
-|                                        | **Toolkits**                    | 100+ built in toolkits with thousands of tools covering data, code, web, and enterprise APIs. |
-| **Runtime & Evaluation**               | **Runtime**                     | Prebuilt FastAPI runtime with SSE compatible endpoints. Production ready from day one. |
-|                                        | **Control Plane (UI)**          | Integrated interface to test, observe, and debug your agents, teams, and workflows in real time. |
-|                                        | **Natively Multimodal**         | Agents can process and generate text, images, audio, video, and files. |
-|                                        | **Evals**                       | Measure Accuracy, Performance, Latency, and Reliability across agents and workflows. |
-|                                        | **Durable Execution**           | Built in support for long running, resumable workflows. |
-| **Security & Privacy**                 | **Private by Design**           | Runs entirely in your cloud. The UI connects directly to your AgentOS from your browser, no data is ever sent externally. |
-|                                        | **Data Governance**             | Your data lives securely in your Agent database, no external data sharing or vendor lock-in.                              |
-|                                        | **Access Control**              | Role-based access (RBAC) and per-agent permissions to protect sensitive contexts and tools.                               |
-
-Every part of Agno is built for real-world deployment — where developer experience meets production performance.
-
-## Setup Your Coding Agent to Use Agno
-
-For LLMs and AI assistants to understand and navigate Agno's documentation, we provide an [llms.txt](https://docs.agno.com/llms.txt) or [llms-full.txt](https://docs.agno.com/llms-full.txt) file. This file is built for AI systems to efficiently parse and reference our documentation.
-
-### IDE Integration
-
-When building Agno agents, using Agno documentation as a source in your IDE is a great way to speed up your development. Here's how to integrate with Cursor:
-
-1. In Cursor, go to the "Cursor Settings" menu.
-2. Find the "Indexing & Docs" section.
-3. Add `https://docs.agno.com/llms-full.txt` to the list of documentation URLs.
-4. Save the changes.
-
-Now, Cursor will have access to the Agno documentation. You can do the same with other IDEs like VSCode, Windsurf etc.
+### Core:
+- Model agnostic — works with OpenAI, Anthropic, Google, local models, whatever
+- Type-safe I/O with `input_schema` and `output_schema`
+- Async-first, built for long-running tasks
+- Natively multimodal (text, images, audio, video, files)
+
+### Memory & Knowledge:
+- Persistent storage for session history and state
+- User memory that persists across sessions
+- Agentic RAG with 20+ vector stores, hybrid search, reranking
+- Culture — shared long-term memory across agents
+
+### Execution:
+- Human-in-the-loop (confirmations, approvals, overrides)
+- Guardrails for validation and security
+- Pre/post hooks for the agent lifecycle
+- First-class MCP and A2A support
+- 100+ built-in toolkits
+
+### Production:
+- Ready-to-use FastAPI runtime
+- Integrated control plane UI
+- Evals for accuracy, performance, latency
+- Durable execution for resumable workflows
+- RBAC and per-agent permissions
 
 ## Performance
 
-If you're building with Agno, you're guaranteed best-in-class performance by default. Our obsession with performance is necessary because even simple AI workflows can spawn hundreds of Agents and because many tasks are long-running -- stateless, horizontal scalability is key for success.
-
-At Agno, we optimize performance across 3 dimensions:
-
-1. **Agent performance:** We optimize static operations (instantiation, memory footprint) and runtime operations (tool calls, memory updates, history management).
-2. **System performance:** The AgentOS API is async by default and has a minimal memory footprint. The system is stateless and horizontally scalable, with a focus on preventing memory leaks. It handles parallel and batch embedding generation during knowledge ingestion, metrics collection in background tasks, and other system-level optimizations.
-3. **Agent reliability and accuracy:** Monitored through evals, which we'll explore later.
-
-### Agent Performance
-
-Let's measure the time it takes to instantiate an Agent and the memory footprint of an Agent. Here are the numbers (last measured in Oct 2025, on an Apple M4 MacBook Pro):
-
-- **Agent instantiation:** ~3μs on average
-- **Memory footprint:** ~6.6Kib on average
-
-We'll show below that Agno Agents instantiate **529× faster than Langgraph**, **57× faster than PydanticAI**, and **70× faster than CrewAI**. Agno Agents also use **24× lower memory than Langgraph**, **4× lower than PydanticAI**, and **10× lower than CrewAI**.
-
-> [!NOTE]
-> Run time performance is bottlenecked by inference and hard to benchmark accurately, so we focus on minimizing overhead, reducing memory usage, and parallelizing tool calls.
-
-### Instantiation Time
+We're obsessive about performance because agent workloads spawn hundreds of instances and run long tasks. Stateless, horizontal scalability isn't optional.
 
-Let's measure instantiation time for an Agent with 1 tool. We'll run the evaluation 1000 times to get a baseline measurement. We'll compare Agno to LangGraph, CrewAI and Pydantic AI.
+**Benchmarks** (Apple M4 MacBook Pro, Oct 2025):
 
-> [!NOTE]
-> The code for this benchmark is available [here](https://github.com/agno-agi/agno/tree/main/cookbook/evals/performance). You should run the evaluation yourself on your own machine, please, do not take these results at face value.
+| Metric | Agno | LangGraph | PydanticAI | CrewAI |
+|--------|------|-----------|------------|--------|
+| Instantiation | **3μs** | 1,587μs (529× slower) | 170μs (57× slower) | 210μs (70× slower) |
+| Memory | **6.6 KiB** | 161 KiB (24× higher) | 29 KiB (4× higher) | 66 KiB (10× higher) |
 
-```shell
-# Setup virtual environment
-./scripts/perf_setup.sh
-source .venvs/perfenv/bin/activate
-
-# Agno
-python cookbook/evals/performance/instantiate_agent_with_tool.py
-
-# LangGraph
-python cookbook/evals/performance/comparison/langgraph_instantiation.py
-# CrewAI
-python cookbook/evals/performance/comparison/crewai_instantiation.py
-# Pydantic AI
-python cookbook/evals/performance/comparison/pydantic_ai_instantiation.py
-```
-
-LangGraph is on the right, **let's start it first and give it a head start**. Then CrewAI and Pydantic AI follow, and finally Agno. Agno obviously finishes first, but let's see by how much.
+Run the benchmarks yourself: [`cookbook/12_evals/performance`](https://github.com/agno-agi/agno/tree/main/cookbook/12_evals/performance)
 
 https://github.com/user-attachments/assets/54b98576-1859-4880-9f2d-15e1a426719d
 
-### Memory Usage
-
-To measure memory usage, we use the `tracemalloc` library. We first calculate a baseline memory usage by running an empty function, then run the Agent 1000x times and calculate the difference. This gives a (reasonably) isolated measurement of the memory usage of the Agent.
-
-We recommend running the evaluation yourself on your own machine, and digging into the code to see how it works. If we've made a mistake, please let us know.
-
-### Results
-
-Taking Agno as the baseline, we can see that:
-
-| Metric             | Agno | Langgraph   | PydanticAI | CrewAI     |
-| ------------------ | ---- | ----------- | ---------- | ---------- |
-| **Time (seconds)** | 1×   | 529× slower | 57× slower | 70× slower |
-| **Memory (MiB)**   | 1×   | 24× higher  | 4× higher  | 10× higher |
+## IDE Integration
 
-Exact numbers from the benchmark:
+For AI-assisted development, add our docs to your IDE:
 
-| Metric             | Agno     | Langgraph | PydanticAI | CrewAI   |
-| ------------------ | -------- | --------- | ---------- | -------- |
-| **Time (seconds)** | 0.000003 | 0.001587  | 0.000170   | 0.000210 |
-| **Memory (MiB)**   | 0.006642 | 0.161435  | 0.028712   | 0.065652 |
+**Cursor:** Settings → Indexing & Docs → Add `https://docs.agno.com/llms-full.txt`
 
-> [!NOTE]
-> Agno agents are designed for performance and while we share benchmarks against other frameworks, we should be mindful that accuracy and reliability are more important than speed.
+Works with VSCode, Windsurf, and other AI-enabled editors too.
 
-## Contributions
+## Contributing
 
-We welcome contributions, read our [contributing guide](https://github.com/agno-agi/agno/blob/v2.0/CONTRIBUTING.md) to get started.
+We welcome contributions. See the [contributing guide](https://github.com/agno-agi/agno/blob/v2.0/CONTRIBUTING.md).
 
 ## Telemetry
 
-Agno logs which model an agent used so we can prioritize updates to the most popular providers. You can disable this by setting `AGNO_TELEMETRY=false` in your environment.
+Agno logs which model providers are used so we can prioritize updates. Disable with `AGNO_TELEMETRY=false`.
 
 <p align="left">
   <a href="#top">⬆️ Back to Top</a>