agno 2.3.21__py3-none-any.whl → 2.3.23__py3-none-any.whl

agno/utils/string.py

@@ -2,13 +2,15 @@ import hashlib
 import json
 import re
 import uuid
-from typing import Optional, Type
+from typing import Any, Optional, Type, Union
 from uuid import uuid4
 
 from pydantic import BaseModel, ValidationError
 
 from agno.utils.log import logger
 
+POSTGRES_INVALID_CHARS_REGEX = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\ufffe\uffff]")
+
 
 def is_valid_uuid(uuid_str: str) -> bool:
     """
@@ -275,3 +277,43 @@ def generate_id_from_name(name: Optional[str] = None) -> str:
         return name.lower().replace(" ", "-").replace("_", "-")
     else:
         return str(uuid4())
+
+
+def sanitize_postgres_string(value: Optional[str]) -> Optional[str]:
+    """Remove illegal chars from string values to prevent PostgreSQL encoding errors.
+
+    This function all chars illegal in Postgres UTF-8 text fields.
+    Useful to prevent CharacterNotInRepertoireError when storing strings.
+
+    Args:
+        value: The string value to sanitize.
+
+    Returns:
+        The sanitized string with illegal chars removed, or None if input was None.
+    """
+    if value is None:
+        return None
+    if isinstance(value, str):
+        return POSTGRES_INVALID_CHARS_REGEX.sub("", value)
+
+
+def sanitize_postgres_strings(data: Union[dict, list, str, Any]) -> Union[dict, list, str, Any]:
+    """Recursively sanitize all string values in a dictionary or JSON structure.
+
+    This function traverses dictionaries, lists, and nested structures to find
+    and sanitize all string values, removing null bytes that PostgreSQL cannot handle.
+
+    Args:
+        data: The data structure to sanitize (dict, list, str or any other type).
+
+    Returns:
+        The sanitized data structure with all strings cleaned of null bytes.
+    """
+    if isinstance(data, dict):
+        return {key: sanitize_postgres_strings(value) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [sanitize_postgres_strings(item) for item in data]
+    elif isinstance(data, str):
+        return sanitize_postgres_string(data)
+    else:
+        return data

agno/workflow/condition.py

@@ -279,7 +279,7 @@ class Condition:
             content=f"Condition {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,
         )
 
@@ -460,6 +460,7 @@ class Condition:
             step_type=StepType.CONDITION,
             content=f"Condition {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,
         )
 
@@ -571,7 +572,7 @@ class Condition:
             content=f"Condition {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,
         )
 
@@ -755,5 +756,6 @@ class Condition:
             step_type=StepType.CONDITION,
             content=f"Condition {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/workflow/loop.py

@@ -150,6 +150,7 @@ class Loop:
 
         all_results = []
         iteration = 0
+        early_termination = False
 
         while iteration < self.max_iterations:
             # Execute all steps in this iteration - mirroring workflow logic
@@ -182,6 +183,7 @@ class Loop:
 
                         if any(output.stop for output in step_output):
                             logger.info(f"Early termination requested by step {step_name}")
+                            early_termination = True
                             break
                 else:
                     # Single StepOutput
@@ -191,6 +193,7 @@ class Loop:
 
                     if step_output.stop:
                         logger.info(f"Early termination requested by step {step_name}")
+                        early_termination = True
                         break
 
                 # Update step input for next step
@@ -209,7 +212,11 @@ class Loop:
                         break
                 except Exception as e:
                     logger.warning(f"End condition evaluation failed: {e}")
-                    # Continue with loop if end condition fails
+
+            # Break out of iteration loop if early termination was requested
+            if early_termination:
+                log_debug(f"Loop ending early due to step termination request at iteration {iteration}")
+                break
 
         log_debug(f"Loop End: {self.name} ({iteration} iterations)", center=True, symbol="=")
 
@@ -224,6 +231,7 @@ class Loop:
             step_type=StepType.LOOP,
             content=f"Loop {self.name} completed {iteration} iterations with {len(flattened_results)} total steps",
             success=all(result.success for result in flattened_results) if flattened_results else True,
+            stop=any(result.stop for result in flattened_results) if flattened_results else False,
             steps=flattened_results,
         )
 
@@ -434,6 +442,7 @@ class Loop:
             step_type=StepType.LOOP,
             content=f"Loop {self.name} completed {iteration} iterations with {len(flattened_results)} total steps",
             success=all(result.success for result in flattened_results) if flattened_results else True,
+            stop=any(result.stop for result in flattened_results) if flattened_results else False,
             steps=flattened_results,
         )
 
@@ -462,6 +471,7 @@ class Loop:
 
         all_results = []
         iteration = 0
+        early_termination = False
 
         while iteration < self.max_iterations:
             # Execute all steps in this iteration - mirroring workflow logic
@@ -494,6 +504,7 @@ class Loop:
 
                         if any(output.stop for output in step_output):
                             logger.info(f"Early termination requested by step {step_name}")
+                            early_termination = True
                             break
                 else:
                     # Single StepOutput
@@ -503,6 +514,7 @@ class Loop:
 
                     if step_output.stop:
                         logger.info(f"Early termination requested by step {step_name}")
+                        early_termination = True
                         break
 
                 # Update step input for next step
@@ -525,6 +537,11 @@ class Loop:
                 except Exception as e:
                     logger.warning(f"End condition evaluation failed: {e}")
 
+            # Break out of iteration loop if early termination was requested
+            if early_termination:
+                log_debug(f"Loop ending early due to step termination request at iteration {iteration}")
+                break
+
         # Use workflow logger for async loop completion
         log_debug(f"Async Loop End: {self.name} ({iteration} iterations)", center=True, symbol="=")
 
@@ -539,6 +556,7 @@ class Loop:
             step_type=StepType.LOOP,
             content=f"Loop {self.name} completed {iteration} iterations with {len(flattened_results)} total steps",
             success=all(result.success for result in flattened_results) if flattened_results else True,
+            stop=any(result.stop for result in flattened_results) if flattened_results else False,
             steps=flattened_results,
         )
 
@@ -752,5 +770,6 @@ class Loop:
             step_type=StepType.LOOP,
             content=f"Loop {self.name} completed {iteration} iterations with {len(flattened_results)} total steps",
             success=all(result.success for result in flattened_results) if flattened_results else True,
+            stop=any(result.stop for result in flattened_results) if flattened_results else False,
             steps=flattened_results,
         )

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,42 +202,145 @@ 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 cancel_run(self, run_id: str, auth_token: Optional[str] = None) -> bool:
+    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 acancel_run(self, run_id: str, auth_token: Optional[str] = None) -> bool:
         """Cancel a running workflow execution.
 
         Args:
@@ -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/workflow/workflow.py

@@ -36,6 +36,9 @@ from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.run import RunContext, RunStatus
 from agno.run.agent import RunContentEvent, RunEvent, RunOutput
+from agno.run.cancel import (
+    acancel_run as acancel_run_global,
+)
 from agno.run.cancel import (
     acleanup_run,
     araise_if_cancelled,
@@ -3496,6 +3499,17 @@ class Workflow:
         """
         return cancel_run_global(run_id)
 
+    async def acancel_run(self, run_id: str) -> bool:
+        """Cancel a running workflow execution (async version).
+
+        Args:
+            run_id (str): The run_id to cancel.
+
+        Returns:
+            bool: True if the run was found and marked for cancellation, False otherwise.
+        """
+        return await acancel_run_global(run_id)
+
     @overload
     def run(
         self,

{agno-2.3.21.dist-info → agno-2.3.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.3.21
+Version: 2.3.23
 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"
@@ -425,23 +425,22 @@ Dynamic: license-file
 
 Agno is a multi-agent framework, runtime, and control plane. Use it to build private and secure AI products that run in your cloud.
 
-- **Build** agents, teams, and workflows with memory, knowledge, guardrails, and 100+ toolkits.
+- **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.
 
 ## Why Agno?
 
-- **Your cloud, your data:** AgentOS runs entirely in your infrastructure. Zero data leaves your environment.
-- **Production-ready from day one:** Pre-built FastAPI runtime with SSE endpoints, ready to deploy.
-- **Actually fast:** 529× faster than LangGraph, 24× lower memory. Matters at scale.
+- **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.
 
 ## Getting Started
 
-New to Agno? Start with the [getting started guide](https://github.com/agno-agi/agno/tree/main/cookbook/00_getting_started).
+Start with the [getting started guide](https://github.com/agno-agi/agno/tree/main/cookbook/00_getting_started), then:
 
-Then:
 - 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.
+- Read the [docs](https://docs.agno.com) to learn more
 
 ## Resources
 
@@ -509,26 +508,26 @@ This isn't a privacy mode or enterprise add-on. It's how Agno works.
 
 ## Features
 
-**Core**
+### 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**
+### 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**
+### 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**
+### Production:
 - Ready-to-use FastAPI runtime
 - Integrated control plane UI
 - Evals for accuracy, performance, latency
@@ -546,7 +545,7 @@ We're obsessive about performance because agent workloads spawn hundreds of inst
 | 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) |
 
-Run the benchmarks yourself: [`cookbook/evals/performance`](https://github.com/agno-agi/agno/tree/main/cookbook/evals/performance)
+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