agno 2.3.25__py3-none-any.whl → 2.4.0__py3-none-any.whl

agno/agent/agent.py

@@ -9,7 +9,6 @@ from concurrent.futures import Future
 from dataclasses import dataclass
 from inspect import iscoroutinefunction
 from os import getenv
-from textwrap import dedent
 from typing import (
     Any,
     AsyncIterator,
@@ -34,8 +33,9 @@ from pydantic import BaseModel
 
 from agno.compression.manager import CompressionManager
 from agno.culture.manager import CultureManager
-from agno.db.base import AsyncBaseDb, BaseDb, SessionType, UserMemory
+from agno.db.base import AsyncBaseDb, BaseDb, ComponentType, SessionType, UserMemory
 from agno.db.schemas.culture import CulturalKnowledge
+from agno.db.utils import db_from_dict
 from agno.eval.base import BaseEval
 from agno.exceptions import (
     InputCheckError,
@@ -44,7 +44,7 @@ from agno.exceptions import (
 )
 from agno.filters import FilterExpr
 from agno.guardrails import BaseGuardrail
-from agno.knowledge.knowledge import Knowledge
+from agno.knowledge.protocol import KnowledgeProtocol
 from agno.knowledge.types import KnowledgeFilter
 from agno.learn.machine import LearningMachine
 from agno.media import Audio, File, Image, Video
@@ -55,6 +55,7 @@ from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse, ModelResponseEvent, ToolExecution
 from agno.models.utils import get_model
 from agno.reasoning.step import NextAction, ReasoningStep, ReasoningSteps
+from agno.registry.registry import Registry
 from agno.run import RunContext, RunStatus
 from agno.run.agent import (
     RunEvent,
@@ -121,6 +122,10 @@ from agno.utils.agent import (
 from agno.utils.common import is_typed_dict
 from agno.utils.events import (
     add_error_event,
+    create_compression_completed_event,
+    create_compression_started_event,
+    create_model_request_completed_event,
+    create_model_request_started_event,
     create_parser_model_response_completed_event,
     create_parser_model_response_started_event,
     create_post_hook_completed_event,
@@ -235,7 +240,9 @@ class Agent:
     # Enable the agent to manage memories of the user
     enable_agentic_memory: bool = False
     # If True, the agent creates/updates user memories at the end of runs
-    enable_user_memories: bool = False
+    update_memory_on_run: bool = False
+    # Soon to be deprecated. Use update_memory_on_run
+    enable_user_memories: Optional[bool] = None
     # If True, the agent adds a reference to the user memories in the response
     add_memories_to_context: Optional[bool] = None
 
@@ -254,7 +261,7 @@ class Agent:
     max_tool_calls_from_history: Optional[int] = None
 
     # --- Knowledge ---
-    knowledge: Optional[Knowledge] = None
+    knowledge: Optional[KnowledgeProtocol] = None
     # Enable RAG by adding references from Knowledge to the user prompt.
     # Add knowledge_filters to the Agent class attributes
     knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
@@ -341,6 +348,8 @@ class Agent:
     description: Optional[str] = None
     # List of instructions for the agent.
     instructions: Optional[Union[str, List[str], Callable]] = None
+    # If True, wrap instructions in <instructions> tags. Default is False.
+    use_instruction_tags: bool = False
     # Provide the expected output from the Agent.
     expected_output: Optional[str] = None
     # Additional context added to the end of the system message.
@@ -459,9 +468,6 @@ class Agent:
     # This helps us improve the Agent and provide better support
     telemetry: bool = True
 
-    # Deprecated. Use stream_events instead
-    stream_intermediate_steps: Optional[bool] = None
-
     def __init__(
         self,
         *,
@@ -482,7 +488,8 @@ class Agent:
         db: Optional[Union[BaseDb, AsyncBaseDb]] = None,
         memory_manager: Optional[MemoryManager] = None,
         enable_agentic_memory: bool = False,
-        enable_user_memories: bool = False,
+        update_memory_on_run: bool = False,
+        enable_user_memories: Optional[bool] = None,  # Soon to be deprecated. Use update_memory_on_run
         add_memories_to_context: Optional[bool] = None,
         enable_session_summaries: bool = False,
         add_session_summary_to_context: Optional[bool] = None,
@@ -496,7 +503,7 @@ class Agent:
         store_media: bool = True,
         store_tool_messages: bool = True,
         store_history_messages: bool = True,
-        knowledge: Optional[Knowledge] = None,
+        knowledge: Optional[KnowledgeProtocol] = None,
         knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
         enable_agentic_knowledge_filters: Optional[bool] = None,
         add_knowledge_to_context: bool = False,
@@ -526,6 +533,7 @@ class Agent:
         build_context: bool = True,
         description: Optional[str] = None,
         instructions: Optional[Union[str, List[str], Callable]] = None,
+        use_instruction_tags: bool = False,
         expected_output: Optional[str] = None,
         additional_context: Optional[str] = None,
         markdown: bool = False,
@@ -554,7 +562,6 @@ class Agent:
         save_response_to_file: Optional[str] = None,
         stream: Optional[bool] = None,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         store_events: bool = False,
         events_to_skip: Optional[List[RunEvent]] = None,
         role: Optional[str] = None,
@@ -589,7 +596,13 @@ class Agent:
 
         self.memory_manager = memory_manager
         self.enable_agentic_memory = enable_agentic_memory
-        self.enable_user_memories = enable_user_memories
+
+        if enable_user_memories is not None:
+            self.update_memory_on_run = enable_user_memories
+        else:
+            self.update_memory_on_run = update_memory_on_run
+        self.enable_user_memories = self.update_memory_on_run  # Soon to be deprecated. Use update_memory_on_run
+
         self.add_memories_to_context = add_memories_to_context
 
         self.enable_session_summaries = enable_session_summaries
@@ -654,9 +667,9 @@ class Agent:
         self.system_message = system_message
         self.system_message_role = system_message_role
         self.build_context = build_context
-
         self.description = description
         self.instructions = instructions
+        self.use_instruction_tags = use_instruction_tags
         self.expected_output = expected_output
         self.additional_context = additional_context
         self.markdown = markdown
@@ -688,14 +701,7 @@ class Agent:
         self.save_response_to_file = save_response_to_file
 
         self.stream = stream
-
-        if stream_intermediate_steps is not None:
-            warnings.warn(
-                "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Use 'stream_events' instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        self.stream_events = stream_events or stream_intermediate_steps
+        self.stream_events = stream_events
 
         self.store_events = store_events
         self.role = role
@@ -823,7 +829,7 @@ class Agent:
 
         if self.add_memories_to_context is None:
             self.add_memories_to_context = (
-                self.enable_user_memories or self.enable_agentic_memory or self.memory_manager is not None
+                self.update_memory_on_run or self.enable_agentic_memory or self.memory_manager is not None
             )
 
     def _set_learning_machine(self) -> None:
@@ -916,7 +922,7 @@ class Agent:
         self._set_default_model()
         self._set_debug(debug_mode=debug_mode)
         self.set_id()
-        if self.enable_user_memories or self.enable_agentic_memory or self.memory_manager is not None:
+        if self.update_memory_on_run or self.enable_agentic_memory or self.memory_manager is not None:
             self._set_memory_manager()
         if (
             self.add_culture_to_context
@@ -1020,22 +1026,6 @@ class Agent:
 
         return session_id, user_id
 
-    def _initialize_session_state(
-        self,
-        session_state: Dict[str, Any],
-        user_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-        run_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """Initialize the session state for the agent."""
-        if user_id:
-            session_state["current_user_id"] = user_id
-        if session_id is not None:
-            session_state["current_session_id"] = session_id
-        if run_id is not None:
-            session_state["current_run_id"] = run_id
-        return session_state
-
     def _run(
         self,
         run_response: RunOutput,
@@ -1161,7 +1151,9 @@ class Agent:
                     raise_if_cancelled(run_response.run_id)  # type: ignore
 
                     # 5. Reason about the task
-                    self._handle_reasoning(run_response=run_response, run_messages=run_messages)
+                    self._handle_reasoning(
+                        run_response=run_response, run_messages=run_messages, run_context=run_context
+                    )
 
                     # Check for cancellation before model call
                     raise_if_cancelled(run_response.run_id)  # type: ignore
@@ -1467,6 +1459,7 @@ class Agent:
                     yield from self._handle_reasoning_stream(
                         run_response=run_response,
                         run_messages=run_messages,
+                        run_context=run_context,
                         stream_events=stream_events,
                     )
 
@@ -1541,6 +1534,7 @@ class Agent:
                             run_response=run_response,
                             events_to_skip=self.events_to_skip,
                             store_events=self.store_events,
+                            get_memories_callback=lambda: self.get_user_memories(user_id=user_id),
                         )
 
                         # Handle the paused run
@@ -1579,6 +1573,9 @@ class Agent:
                         learning_future=learning_future,  # type: ignore
                         stream_events=stream_events,
                         run_response=run_response,
+                        events_to_skip=self.events_to_skip,
+                        store_events=self.store_events,
+                        get_memories_callback=lambda: self.get_user_memories(user_id=user_id),
                     )
 
                     # 9. Create session summary
@@ -1742,7 +1739,6 @@ class Agent:
         *,
         stream: Literal[False] = False,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         user_id: Optional[str] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -1770,7 +1766,6 @@ class Agent:
         *,
         stream: Literal[True] = True,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         user_id: Optional[str] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -1787,7 +1782,6 @@ class Agent:
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
         output_schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
-        yield_run_response: Optional[bool] = None,  # To be deprecated: use yield_run_output instead
         yield_run_output: bool = False,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -1799,7 +1793,6 @@ class Agent:
         *,
         stream: Optional[bool] = None,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         user_id: Optional[str] = None,
         session_id: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -1816,7 +1809,6 @@ class Agent:
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
         output_schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
-        yield_run_response: Optional[bool] = None,  # To be deprecated: use yield_run_output instead
         yield_run_output: Optional[bool] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -1838,13 +1830,6 @@ class Agent:
                 "add_history_to_context is True, but no database has been assigned to the agent. History will not be added to the context."
             )
 
-        if yield_run_response is not None:
-            warnings.warn(
-                "The 'yield_run_response' parameter is deprecated and will be removed in future versions. Use 'yield_run_output' instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
         background_tasks = kwargs.pop("background_tasks", None)
         if background_tasks is not None:
             from fastapi import BackgroundTasks
@@ -1884,14 +1869,8 @@ class Agent:
         agent_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
         self._update_metadata(session=agent_session)
 
-        # Initialize session state
-        session_state = self._initialize_session_state(
-            session_state=session_state if session_state is not None else {},
-            user_id=user_id,
-            session_id=session_id,
-            run_id=run_id,
-        )
-        # Update session state from DB
+        # Initialize session state. Get it from DB if relevant.
+        session_state = session_state if session_state is not None else {}
         session_state = self._load_session_state(session=agent_session, session_state=session_state)
 
         # Determine runtime dependencies
@@ -1935,15 +1914,6 @@ class Agent:
         if stream is None:
             stream = False if self.stream is None else self.stream
 
-        # Considering both stream_events and stream_intermediate_steps (deprecated)
-        if stream_intermediate_steps is not None:
-            warnings.warn(
-                "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Use 'stream_events' instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        stream_events = stream_events or stream_intermediate_steps
-
         # Can't stream events if streaming is disabled
         if stream is False:
             stream_events = False
@@ -1978,8 +1948,6 @@ class Agent:
         run_response.metrics = Metrics()
         run_response.metrics.start_timer()
 
-        yield_run_output = yield_run_output or yield_run_response  # For backwards compatibility
-
         if stream:
             response_iterator = self._run_stream(
                 run_response=run_response,
@@ -2068,18 +2036,12 @@ class Agent:
 
                     # 2. Update metadata and session state
                     self._update_metadata(session=agent_session)
-                    # Initialize session state
-                    run_context.session_state = self._initialize_session_state(
+
+                    # Initialize session state. Get it from DB if relevant.
+                    run_context.session_state = self._load_session_state(
+                        session=agent_session,
                         session_state=run_context.session_state if run_context.session_state is not None else {},
-                        user_id=user_id,
-                        session_id=session_id,
-                        run_id=run_response.run_id,
                     )
-                    # Update session state from DB
-                    if run_context.session_state is not None:
-                        run_context.session_state = self._load_session_state(
-                            session=agent_session, session_state=run_context.session_state
-                        )
 
                     # 3. Resolve dependencies
                     if run_context.dependencies is not None:
@@ -2168,7 +2130,9 @@ class Agent:
                     await araise_if_cancelled(run_response.run_id)  # type: ignore
 
                     # 8. Reason about the task if reasoning is enabled
-                    await self._ahandle_reasoning(run_response=run_response, run_messages=run_messages)
+                    await self._ahandle_reasoning(
+                        run_response=run_response, run_messages=run_messages, run_context=run_context
+                    )
 
                     # Check for cancellation before model call
                     await araise_if_cancelled(run_response.run_id)  # type: ignore
@@ -2435,18 +2399,12 @@ class Agent:
 
                     # 2. Update metadata and session state
                     self._update_metadata(session=agent_session)
-                    # Initialize session state
-                    run_context.session_state = self._initialize_session_state(
+
+                    # Initialize session state. Get it from DB if relevant.
+                    run_context.session_state = self._load_session_state(
+                        session=agent_session,
                         session_state=run_context.session_state if run_context.session_state is not None else {},
-                        user_id=user_id,
-                        session_id=session_id,
-                        run_id=run_response.run_id,
                     )
-                    # Update session state from DB
-                    if run_context.session_state is not None:
-                        run_context.session_state = self._load_session_state(
-                            session=agent_session, session_state=run_context.session_state
-                        )
 
                     # 3. Resolve dependencies
                     if run_context.dependencies is not None:
@@ -2535,6 +2493,7 @@ class Agent:
                     async for item in self._ahandle_reasoning_stream(
                         run_response=run_response,
                         run_messages=run_messages,
+                        run_context=run_context,
                         stream_events=stream_events,
                     ):
                         await araise_if_cancelled(run_response.run_id)  # type: ignore
@@ -2620,6 +2579,9 @@ class Agent:
                             learning_task=learning_task,
                             stream_events=stream_events,
                             run_response=run_response,
+                            events_to_skip=self.events_to_skip,
+                            store_events=self.store_events,
+                            get_memories_callback=lambda: self.aget_user_memories(user_id=user_id),
                         ):
                             yield item
 
@@ -2653,6 +2615,7 @@ class Agent:
                         run_response=run_response,
                         events_to_skip=self.events_to_skip,
                         store_events=self.store_events,
+                        get_memories_callback=lambda: self.aget_user_memories(user_id=user_id),
                     ):
                         yield item
 
@@ -2870,7 +2833,6 @@ class Agent:
         videos: Optional[Sequence[Video]] = None,
         files: Optional[Sequence[File]] = None,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
         add_history_to_context: Optional[bool] = None,
         add_dependencies_to_context: Optional[bool] = None,
@@ -2897,7 +2859,6 @@ class Agent:
         videos: Optional[Sequence[Video]] = None,
         files: Optional[Sequence[File]] = None,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
         add_history_to_context: Optional[bool] = None,
         add_dependencies_to_context: Optional[bool] = None,
@@ -2905,7 +2866,6 @@ class Agent:
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
         output_schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
-        yield_run_response: Optional[bool] = None,  # To be deprecated: use yield_run_output instead
         yield_run_output: Optional[bool] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -2926,7 +2886,6 @@ class Agent:
         videos: Optional[Sequence[Video]] = None,
         files: Optional[Sequence[File]] = None,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
         add_history_to_context: Optional[bool] = None,
         add_dependencies_to_context: Optional[bool] = None,
@@ -2934,7 +2893,6 @@ class Agent:
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
         output_schema: Optional[Union[Type[BaseModel], Dict[str, Any]]] = None,
-        yield_run_response: Optional[bool] = None,  # To be deprecated: use yield_run_output instead
         yield_run_output: Optional[bool] = None,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
@@ -2949,13 +2907,6 @@ class Agent:
                 "add_history_to_context is True, but no database has been assigned to the agent. History will not be added to the context."
             )
 
-        if yield_run_response is not None:
-            warnings.warn(
-                "The 'yield_run_response' parameter is deprecated and will be removed in future versions. Use 'yield_run_output' instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
         background_tasks = kwargs.pop("background_tasks", None)
         if background_tasks is not None:
             from fastapi import BackgroundTasks
@@ -3008,15 +2959,6 @@ class Agent:
         if stream is None:
             stream = False if self.stream is None else self.stream
 
-        # Considering both stream_events and stream_intermediate_steps (deprecated)
-        if stream_intermediate_steps is not None:
-            warnings.warn(
-                "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Use 'stream_events' instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        stream_events = stream_events or stream_intermediate_steps
-
         # Can't stream events if streaming is disabled
         if stream is False:
             stream_events = False
@@ -3078,7 +3020,7 @@ class Agent:
         run_response.metrics = Metrics()
         run_response.metrics.start_timer()
 
-        yield_run_output = yield_run_output or yield_run_response  # For backwards compatibility
+        yield_run_output = yield_run_output
 
         # Pass the new run_response to _arun
         if stream:
@@ -3122,7 +3064,6 @@ class Agent:
         requirements: Optional[List[RunRequirement]] = None,
         stream: Literal[False] = False,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         user_id: Optional[str] = None,
         session_id: Optional[str] = None,
         knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
@@ -3142,7 +3083,6 @@ class Agent:
         requirements: Optional[List[RunRequirement]] = None,
         stream: Literal[True] = True,
         stream_events: Optional[bool] = False,
-        stream_intermediate_steps: Optional[bool] = None,
         user_id: Optional[str] = None,
         session_id: Optional[str] = None,
         knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
@@ -3161,7 +3101,6 @@ class Agent:
         requirements: Optional[List[RunRequirement]] = None,
         stream: Optional[bool] = None,
         stream_events: Optional[bool] = False,
-        stream_intermediate_steps: Optional[bool] = None,
         user_id: Optional[str] = None,
         session_id: Optional[str] = None,
         run_context: Optional[RunContext] = None,
@@ -3187,8 +3126,6 @@ class Agent:
             dependencies: The dependencies to use for the run.
             metadata: The metadata to use for the run.
             debug_mode: Whether to enable debug mode.
-            (deprecated) stream_intermediate_steps: Whether to stream all steps.
-            (deprecated) updated_tools: Use 'requirements' instead.
         """
         if run_response is None and run_id is None:
             raise ValueError("Either run_response or run_id must be provided.")
@@ -3219,12 +3156,8 @@ class Agent:
         agent_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
         self._update_metadata(session=agent_session)
 
-        # Initialize session state
-        session_state = self._initialize_session_state(
-            session_state={}, user_id=user_id, session_id=session_id, run_id=run_id
-        )
-        # Update session state from DB
-        session_state = self._load_session_state(session=agent_session, session_state=session_state)
+        # Initialize session state. Get it from DB if relevant.
+        session_state = self._load_session_state(session=agent_session, session_state={})
 
         dependencies = dependencies if dependencies is not None else self.dependencies
 
@@ -3257,15 +3190,6 @@ class Agent:
         if stream is None:
             stream = False if self.stream is None else self.stream
 
-        # Considering both stream_events and stream_intermediate_steps (deprecated)
-        if stream_intermediate_steps is not None:
-            warnings.warn(
-                "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Use 'stream_events' instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        stream_events = stream_events or stream_intermediate_steps
-
         # Can't stream events if streaming is disabled
         if stream is False:
             stream_events = False
@@ -3273,10 +3197,6 @@ class Agent:
         if stream_events is None:
             stream_events = False if self.stream_events is None else self.stream_events
 
-        # Can't stream events if streaming is disabled
-        if stream is False:
-            stream_events = False
-
         # Run can be continued from previous run response or from passed run_response context
         if run_response is not None:
             # The run is continued from a provided run_response. This contains the updated tools.
@@ -3817,7 +3737,6 @@ class Agent:
         *,
         stream: Literal[False] = False,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         run_id: Optional[str] = None,
         updated_tools: Optional[List[ToolExecution]] = None,
         requirements: Optional[List[RunRequirement]] = None,
@@ -3837,7 +3756,6 @@ class Agent:
         *,
         stream: Literal[True] = True,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         run_id: Optional[str] = None,
         updated_tools: Optional[List[ToolExecution]] = None,
         requirements: Optional[List[RunRequirement]] = None,
@@ -3859,7 +3777,6 @@ class Agent:
         requirements: Optional[List[RunRequirement]] = None,
         stream: Optional[bool] = None,
         stream_events: Optional[bool] = None,
-        stream_intermediate_steps: Optional[bool] = None,
         user_id: Optional[str] = None,
         session_id: Optional[str] = None,
         run_context: Optional[RunContext] = None,
@@ -3887,7 +3804,6 @@ class Agent:
             metadata: The metadata to use for continuing the run.
             debug_mode: Whether to enable debug mode.
             yield_run_output: Whether to yield the run response.
-            (deprecated) stream_intermediate_steps: Whether to stream all steps.
             (deprecated) updated_tools: Use 'requirements' instead.
         """
         if run_response is None and run_id is None:
@@ -3923,15 +3839,6 @@ class Agent:
         if stream is None:
             stream = False if self.stream is None else self.stream
 
-        # Considering both stream_events and stream_intermediate_steps (deprecated)
-        if stream_intermediate_steps is not None:
-            warnings.warn(
-                "The 'stream_intermediate_steps' parameter is deprecated and will be removed in future versions. Use 'stream_events' instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        stream_events = stream_events or stream_intermediate_steps
-
         # Can't stream events if streaming is disabled
         if stream is False:
             stream_events = False
@@ -3939,7 +3846,7 @@ class Agent:
         if stream_events is None:
             stream_events = False if self.stream_events is None else self.stream_events
 
-        # Can't have stream_intermediate_steps if stream is False
+        # Can't have stream_events if stream is False
         if stream is False:
             stream_events = False
 
@@ -4052,15 +3959,12 @@ class Agent:
 
                     # 3. Update metadata and session state
                     self._update_metadata(session=agent_session)
-                    # Initialize session state
-                    run_context.session_state = self._initialize_session_state(
-                        session_state={}, user_id=user_id, session_id=session_id, run_id=run_id
-                    )
-                    # Update session state from DB
-                    if run_context.session_state is not None:
-                        run_context.session_state = self._load_session_state(
-                            session=agent_session, session_state=run_context.session_state
-                        )
+
+                    # Initialize session state. Get it from DB if relevant.
+                    run_context.session_state = self._load_session_state(
+                        session=agent_session,
+                        session_state=run_context.session_state if run_context.session_state is not None else {},
+                    )
 
                     # 4. Prepare run response
                     if run_response is not None:
@@ -4357,15 +4261,12 @@ class Agent:
 
                     # 2. Update session state and metadata
                     self._update_metadata(session=agent_session)
-                    # Initialize session state
-                    run_context.session_state = self._initialize_session_state(
-                        session_state={}, user_id=user_id, session_id=session_id, run_id=run_id
-                    )
-                    # Update session state from DB
-                    if run_context.session_state is not None:
-                        run_context.session_state = self._load_session_state(
-                            session=agent_session, session_state=run_context.session_state
-                        )
+
+                    # Initialize session state. Get it from DB if relevant.
+                    run_context.session_state = self._load_session_state(
+                        session=agent_session,
+                        session_state=run_context.session_state if run_context.session_state is not None else {},
+                    )
 
                     # 3. Resolve dependencies
                     if run_context.dependencies is not None:
@@ -4746,9 +4647,6 @@ class Agent:
             "run_context": run_context,
             "agent": self,
             "session": session,
-            "session_state": run_context.session_state,
-            "dependencies": run_context.dependencies,
-            "metadata": run_context.metadata,
             "user_id": user_id,
             "debug_mode": debug_mode or self.debug_mode,
         }
@@ -4841,9 +4739,6 @@ class Agent:
             "agent": self,
             "session": session,
             "run_context": run_context,
-            "session_state": run_context.session_state,
-            "dependencies": run_context.dependencies,
-            "metadata": run_context.metadata,
             "user_id": user_id,
             "debug_mode": debug_mode or self.debug_mode,
         }
@@ -4939,9 +4834,6 @@ class Agent:
             "run_output": run_output,
             "agent": self,
             "session": session,
-            "session_state": run_context.session_state,
-            "dependencies": run_context.dependencies,
-            "metadata": run_context.metadata,
             "user_id": user_id,
             "run_context": run_context,
             "debug_mode": debug_mode or self.debug_mode,
@@ -5028,9 +4920,6 @@ class Agent:
             "agent": self,
             "session": session,
             "run_context": run_context,
-            "session_state": run_context.session_state,
-            "dependencies": run_context.dependencies,
-            "metadata": run_context.metadata,
             "user_id": user_id,
             "debug_mode": debug_mode or self.debug_mode,
         }
@@ -5701,6 +5590,70 @@ class Agent:
             send_media_to_model=self.send_media_to_model,
             compression_manager=self.compression_manager if self.compress_tool_results else None,
         ):
+            # Handle LLM request events and compression events from ModelResponse
+            if isinstance(model_response_event, ModelResponse):
+                if model_response_event.event == ModelResponseEvent.model_request_started.value:
+                    if stream_events:
+                        yield handle_event(  # type: ignore
+                            create_model_request_started_event(
+                                from_run_response=run_response,
+                                model=self.model.id,
+                                model_provider=self.model.provider,
+                            ),
+                            run_response,
+                            events_to_skip=self.events_to_skip,  # type: ignore
+                            store_events=self.store_events,
+                        )
+                    continue
+
+                if model_response_event.event == ModelResponseEvent.model_request_completed.value:
+                    if stream_events:
+                        yield handle_event(  # type: ignore
+                            create_model_request_completed_event(
+                                from_run_response=run_response,
+                                model=self.model.id,
+                                model_provider=self.model.provider,
+                                input_tokens=model_response_event.input_tokens,
+                                output_tokens=model_response_event.output_tokens,
+                                total_tokens=model_response_event.total_tokens,
+                                time_to_first_token=model_response_event.time_to_first_token,
+                                reasoning_tokens=model_response_event.reasoning_tokens,
+                                cache_read_tokens=model_response_event.cache_read_tokens,
+                                cache_write_tokens=model_response_event.cache_write_tokens,
+                            ),
+                            run_response,
+                            events_to_skip=self.events_to_skip,  # type: ignore
+                            store_events=self.store_events,
+                        )
+                    continue
+
+                # Handle compression events
+                if model_response_event.event == ModelResponseEvent.compression_started.value:
+                    if stream_events:
+                        yield handle_event(  # type: ignore
+                            create_compression_started_event(from_run_response=run_response),
+                            run_response,
+                            events_to_skip=self.events_to_skip,  # type: ignore
+                            store_events=self.store_events,
+                        )
+                    continue
+
+                if model_response_event.event == ModelResponseEvent.compression_completed.value:
+                    if stream_events:
+                        stats = model_response_event.compression_stats or {}
+                        yield handle_event(  # type: ignore
+                            create_compression_completed_event(
+                                from_run_response=run_response,
+                                tool_results_compressed=stats.get("tool_results_compressed"),
+                                original_size=stats.get("original_size"),
+                                compressed_size=stats.get("compressed_size"),
+                            ),
+                            run_response,
+                            events_to_skip=self.events_to_skip,  # type: ignore
+                            store_events=self.store_events,
+                        )
+                    continue
+
             yield from self._handle_model_response_chunk(
                 session=session,
                 run_response=run_response,
@@ -5713,6 +5666,16 @@ class Agent:
                 run_context=run_context,
             )
 
+        # Update RunOutput
+        # Build a list of messages that should be added to the RunOutput
+        messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
+        # Update the RunOutput messages
+        run_response.messages = messages_for_run_response
+        # Update the RunOutput metrics
+        run_response.metrics = self._calculate_run_metrics(
+            messages=messages_for_run_response, current_run_metrics=run_response.metrics
+        )
+
         # Determine reasoning completed
         if stream_events and reasoning_state["reasoning_started"]:
             all_reasoning_steps: List[ReasoningStep] = []
@@ -5735,16 +5698,6 @@ class Agent:
                     store_events=self.store_events,
                 )
 
-        # Update RunOutput
-        # Build a list of messages that should be added to the RunOutput
-        messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
-        # Update the RunOutput messages
-        run_response.messages = messages_for_run_response
-        # Update the RunOutput metrics
-        run_response.metrics = self._calculate_run_metrics(
-            messages=messages_for_run_response, current_run_metrics=run_response.metrics
-        )
-
         # Update the run_response audio if streaming
         if model_response.audio is not None:
             run_response.response_audio = model_response.audio
@@ -5790,6 +5743,70 @@ class Agent:
         )  # type: ignore
 
         async for model_response_event in model_response_stream:  # type: ignore
+            # Handle LLM request events and compression events from ModelResponse
+            if isinstance(model_response_event, ModelResponse):
+                if model_response_event.event == ModelResponseEvent.model_request_started.value:
+                    if stream_events:
+                        yield handle_event(  # type: ignore
+                            create_model_request_started_event(
+                                from_run_response=run_response,
+                                model=self.model.id,
+                                model_provider=self.model.provider,
+                            ),
+                            run_response,
+                            events_to_skip=self.events_to_skip,  # type: ignore
+                            store_events=self.store_events,
+                        )
+                    continue
+
+                if model_response_event.event == ModelResponseEvent.model_request_completed.value:
+                    if stream_events:
+                        yield handle_event(  # type: ignore
+                            create_model_request_completed_event(
+                                from_run_response=run_response,
+                                model=self.model.id,
+                                model_provider=self.model.provider,
+                                input_tokens=model_response_event.input_tokens,
+                                output_tokens=model_response_event.output_tokens,
+                                total_tokens=model_response_event.total_tokens,
+                                time_to_first_token=model_response_event.time_to_first_token,
+                                reasoning_tokens=model_response_event.reasoning_tokens,
+                                cache_read_tokens=model_response_event.cache_read_tokens,
+                                cache_write_tokens=model_response_event.cache_write_tokens,
+                            ),
+                            run_response,
+                            events_to_skip=self.events_to_skip,  # type: ignore
+                            store_events=self.store_events,
+                        )
+                    continue
+
+                # Handle compression events
+                if model_response_event.event == ModelResponseEvent.compression_started.value:
+                    if stream_events:
+                        yield handle_event(  # type: ignore
+                            create_compression_started_event(from_run_response=run_response),
+                            run_response,
+                            events_to_skip=self.events_to_skip,  # type: ignore
+                            store_events=self.store_events,
+                        )
+                    continue
+
+                if model_response_event.event == ModelResponseEvent.compression_completed.value:
+                    if stream_events:
+                        stats = model_response_event.compression_stats or {}
+                        yield handle_event(  # type: ignore
+                            create_compression_completed_event(
+                                from_run_response=run_response,
+                                tool_results_compressed=stats.get("tool_results_compressed"),
+                                original_size=stats.get("original_size"),
+                                compressed_size=stats.get("compressed_size"),
+                            ),
+                            run_response,
+                            events_to_skip=self.events_to_skip,  # type: ignore
+                            store_events=self.store_events,
+                        )
+                    continue
+
             for event in self._handle_model_response_chunk(
                 session=session,
                 run_response=run_response,
@@ -5803,6 +5820,16 @@ class Agent:
             ):
                 yield event
 
+        # Update RunOutput
+        # Build a list of messages that should be added to the RunOutput
+        messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
+        # Update the RunOutput messages
+        run_response.messages = messages_for_run_response
+        # Update the RunOutput metrics
+        run_response.metrics = self._calculate_run_metrics(
+            messages=messages_for_run_response, current_run_metrics=run_response.metrics
+        )
+
         if stream_events and reasoning_state["reasoning_started"]:
             all_reasoning_steps: List[ReasoningStep] = []
             if run_response and run_response.reasoning_steps:
@@ -5824,16 +5851,6 @@ class Agent:
                     store_events=self.store_events,
                 )
 
-        # Update RunOutput
-        # Build a list of messages that should be added to the RunOutput
-        messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
-        # Update the RunOutput messages
-        run_response.messages = messages_for_run_response
-        # Update the RunOutput metrics
-        run_response.metrics = self._calculate_run_metrics(
-            messages=messages_for_run_response, current_run_metrics=run_response.metrics
-        )
-
         # Update the run_response audio if streaming
         if model_response.audio is not None:
             run_response.response_audio = model_response.audio
@@ -6224,7 +6241,7 @@ class Agent:
             user_message_str is not None
             and user_message_str.strip() != ""
             and self.memory_manager is not None
-            and self.enable_user_memories
+            and self.update_memory_on_run
         ):
             log_debug("Managing user memories")
             self.memory_manager.create_user_memories(  # type: ignore
@@ -6253,7 +6270,7 @@ class Agent:
                 for msg in parsed_messages
                 if msg.content and (not isinstance(msg.content, str) or msg.content.strip() != "")
             ]
-            if len(non_empty_messages) > 0 and self.memory_manager is not None and self.enable_user_memories:
+            if len(non_empty_messages) > 0 and self.memory_manager is not None and self.update_memory_on_run:
                 self.memory_manager.create_user_memories(messages=non_empty_messages, user_id=user_id, agent_id=self.id)  # type: ignore
             else:
                 log_warning("Unable to add messages to memory")
@@ -6270,7 +6287,7 @@ class Agent:
             user_message_str is not None
             and user_message_str.strip() != ""
             and self.memory_manager is not None
-            and self.enable_user_memories
+            and self.update_memory_on_run
         ):
             log_debug("Managing user memories")
             await self.memory_manager.acreate_user_memories(  # type: ignore
@@ -6299,7 +6316,7 @@ class Agent:
                 for msg in parsed_messages
                 if msg.content and (not isinstance(msg.content, str) or msg.content.strip() != "")
             ]
-            if len(non_empty_messages) > 0 and self.memory_manager is not None and self.enable_user_memories:
+            if len(non_empty_messages) > 0 and self.memory_manager is not None and self.update_memory_on_run:
                 await self.memory_manager.acreate_user_memories(  # type: ignore
                     messages=non_empty_messages, user_id=user_id, agent_id=self.id
                 )
@@ -6334,7 +6351,7 @@ class Agent:
         if (
             run_messages.user_message is not None
             and self.memory_manager is not None
-            and self.enable_user_memories
+            and self.update_memory_on_run
             and not self.enable_agentic_memory
         ):
             log_debug("Starting memory creation in background task.")
@@ -6487,7 +6504,7 @@ class Agent:
         if (
             run_messages.user_message is not None
             and self.memory_manager is not None
-            and self.enable_user_memories
+            and self.update_memory_on_run
             and not self.enable_agentic_memory
         ):
             log_debug("Starting memory creation in background thread.")
@@ -6636,39 +6653,31 @@ class Agent:
             agent_tools.append(Function(name="update_session_state", entrypoint=self._update_session_state_tool))
 
         # Add tools for accessing knowledge
-        if self.knowledge is not None or self.knowledge_retriever is not None:
-            # Check if knowledge retriever is an async function but used in sync mode
-            from inspect import iscoroutinefunction
-
-            if self.knowledge_retriever and iscoroutinefunction(self.knowledge_retriever):
-                log_warning(
-                    "Async knowledge retriever function is being used with synchronous agent.run() or agent.print_response(). "
-                    "It is recommended to use agent.arun() or agent.aprint_response() instead."
+        if self.knowledge is not None and self.search_knowledge:
+            # Use knowledge protocol's get_tools method
+            get_tools_fn = getattr(self.knowledge, "get_tools", None)
+            if callable(get_tools_fn):
+                knowledge_tools = get_tools_fn(
+                    run_response=run_response,
+                    run_context=run_context,
+                    knowledge_filters=run_context.knowledge_filters,
+                    async_mode=False,
+                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
+                    agent=self,
                 )
+                agent_tools.extend(knowledge_tools)
+        elif self.knowledge_retriever is not None and self.search_knowledge:
+            # Create search tool using custom knowledge_retriever
+            agent_tools.append(
+                self._create_knowledge_retriever_search_tool(
+                    run_response=run_response,
+                    run_context=run_context,
+                    async_mode=False,
+                )
+            )
 
-            if self.search_knowledge:
-                # Use async or sync search based on async_mode
-                if self.enable_agentic_knowledge_filters:
-                    agent_tools.append(
-                        self._search_knowledge_base_with_agentic_filters_function(
-                            run_response=run_response,
-                            async_mode=False,
-                            knowledge_filters=run_context.knowledge_filters,
-                            run_context=run_context,
-                        )
-                    )
-                else:
-                    agent_tools.append(
-                        self._get_search_knowledge_base_function(
-                            run_response=run_response,
-                            async_mode=False,
-                            knowledge_filters=run_context.knowledge_filters,
-                            run_context=run_context,
-                        )
-                    )
-
-            if self.update_knowledge:
-                agent_tools.append(self.add_to_knowledge)
+        if self.knowledge is not None and self.update_knowledge:
+            agent_tools.append(self.add_to_knowledge)
 
         # Add tools for accessing skills
         if self.skills is not None:
@@ -6754,30 +6763,43 @@ class Agent:
             agent_tools.append(Function(name="update_session_state", entrypoint=self._update_session_state_tool))
 
         # Add tools for accessing knowledge
-        if self.knowledge is not None or self.knowledge_retriever is not None:
-            if self.search_knowledge:
-                # Use async or sync search based on async_mode
-                if self.enable_agentic_knowledge_filters:
-                    agent_tools.append(
-                        self._search_knowledge_base_with_agentic_filters_function(
-                            run_response=run_response,
-                            async_mode=True,
-                            knowledge_filters=run_context.knowledge_filters,
-                            run_context=run_context,
-                        )
-                    )
-                else:
-                    agent_tools.append(
-                        self._get_search_knowledge_base_function(
-                            run_response=run_response,
-                            async_mode=True,
-                            knowledge_filters=run_context.knowledge_filters,
-                            run_context=run_context,
-                        )
-                    )
+        if self.knowledge is not None and self.search_knowledge:
+            # Use knowledge protocol's get_tools method
+            aget_tools_fn = getattr(self.knowledge, "aget_tools", None)
+            get_tools_fn = getattr(self.knowledge, "get_tools", None)
+
+            if callable(aget_tools_fn):
+                knowledge_tools = await aget_tools_fn(
+                    run_response=run_response,
+                    run_context=run_context,
+                    knowledge_filters=run_context.knowledge_filters,
+                    async_mode=True,
+                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
+                    agent=self,
+                )
+                agent_tools.extend(knowledge_tools)
+            elif callable(get_tools_fn):
+                knowledge_tools = get_tools_fn(
+                    run_response=run_response,
+                    run_context=run_context,
+                    knowledge_filters=run_context.knowledge_filters,
+                    async_mode=True,
+                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
+                    agent=self,
+                )
+                agent_tools.extend(knowledge_tools)
+        elif self.knowledge_retriever is not None and self.search_knowledge:
+            # Create search tool using custom knowledge_retriever
+            agent_tools.append(
+                self._create_knowledge_retriever_search_tool(
+                    run_response=run_response,
+                    run_context=run_context,
+                    async_mode=True,
+                )
+            )
 
-            if self.update_knowledge:
-                agent_tools.append(self.add_to_knowledge)
+        if self.knowledge is not None and self.update_knowledge:
+            agent_tools.append(self.add_to_knowledge)
 
         # Add tools for accessing skills
         if self.skills is not None:
@@ -6785,102 +6807,120 @@ class Agent:
 
         return agent_tools
 
-    def _determine_tools_for_model(
+    def _parse_tools(
         self,
+        tools: List[Union[Toolkit, Callable, Function, Dict]],
         model: Model,
-        processed_tools: List[Union[Toolkit, Callable, Function, Dict]],
-        run_response: RunOutput,
-        run_context: RunContext,
-        session: AgentSession,
+        run_context: Optional[RunContext] = None,
         async_mode: bool = False,
     ) -> List[Union[Function, dict]]:
         _function_names = []
         _functions: List[Union[Function, dict]] = []
         self._tool_instructions = []
 
-        # Get Agent tools
-        if processed_tools is not None and len(processed_tools) > 0:
-            log_debug("Processing tools for model")
-
-            # Get output_schema from run_context
-            output_schema = run_context.output_schema if run_context else None
+        # Get output_schema from run_context
+        output_schema = run_context.output_schema if run_context else None
 
-            # Check if we need strict mode for the functions for the model
-            strict = False
-            if (
-                output_schema is not None
-                and (self.structured_outputs or (not self.use_json_mode))
-                and model.supports_native_structured_outputs
-            ):
-                strict = True
-
-            for tool in processed_tools:
-                if isinstance(tool, Dict):
-                    # If a dict is passed, it is a builtin tool
-                    # that is run by the model provider and not the Agent
-                    _functions.append(tool)
-                    log_debug(f"Included builtin tool {tool}")
-
-                elif isinstance(tool, Toolkit):
-                    # For each function in the toolkit and process entrypoint
-                    toolkit_functions = tool.get_async_functions() if async_mode else tool.get_functions()
-                    for name, _func in toolkit_functions.items():
-                        if name in _function_names:
-                            continue
-                        _function_names.append(name)
-                        _func = _func.model_copy(deep=True)
-                        _func._agent = self
-                        _func.process_entrypoint(strict=strict)
-                        if strict and _func.strict is None:
-                            _func.strict = True
-                        if self.tool_hooks is not None:
-                            _func.tool_hooks = self.tool_hooks
-                        _functions.append(_func)
-                        log_debug(f"Added tool {name} from {tool.name}")
-
-                    # Add instructions from the toolkit
-                    if tool.add_instructions and tool.instructions is not None:
-                        self._tool_instructions.append(tool.instructions)
-
-                elif isinstance(tool, Function):
-                    if tool.name in _function_names:
+        # Check if we need strict mode for the functions for the model
+        strict = False
+        if (
+            output_schema is not None
+            and (self.structured_outputs or (not self.use_json_mode))
+            and model.supports_native_structured_outputs
+        ):
+            strict = True
+
+        for tool in tools:
+            if isinstance(tool, Dict):
+                # If a dict is passed, it is a builtin tool
+                # that is run by the model provider and not the Agent
+                _functions.append(tool)
+                log_debug(f"Included builtin tool {tool}")
+
+            elif isinstance(tool, Toolkit):
+                # For each function in the toolkit and process entrypoint
+                toolkit_functions = tool.get_async_functions() if async_mode else tool.get_functions()
+                for name, _func in toolkit_functions.items():
+                    if name in _function_names:
                         continue
-                    _function_names.append(tool.name)
+                    _function_names.append(name)
+                    _func = _func.model_copy(deep=True)
+                    _func._agent = self
+                    # Respect the function's explicit strict setting if set
+                    effective_strict = strict if _func.strict is None else _func.strict
+                    _func.process_entrypoint(strict=effective_strict)
+                    if strict and _func.strict is None:
+                        _func.strict = True
+                    if self.tool_hooks is not None:
+                        _func.tool_hooks = self.tool_hooks
+                    _functions.append(_func)
+                    log_debug(f"Added tool {name} from {tool.name}")
 
-                    tool.process_entrypoint(strict=strict)
-                    tool = tool.model_copy(deep=True)
+                # Add instructions from the toolkit
+                if tool.add_instructions and tool.instructions is not None:
+                    self._tool_instructions.append(tool.instructions)
 
-                    tool._agent = self
-                    if strict and tool.strict is None:
-                        tool.strict = True
+            elif isinstance(tool, Function):
+                if tool.name in _function_names:
+                    continue
+                _function_names.append(tool.name)
+
+                # Respect the function's explicit strict setting if set
+                effective_strict = strict if tool.strict is None else tool.strict
+                tool.process_entrypoint(strict=effective_strict)
+                tool = tool.model_copy(deep=True)
+
+                tool._agent = self
+                if strict and tool.strict is None:
+                    tool.strict = True
+                if self.tool_hooks is not None:
+                    tool.tool_hooks = self.tool_hooks
+                _functions.append(tool)
+                log_debug(f"Added tool {tool.name}")
+
+                # Add instructions from the Function
+                if tool.add_instructions and tool.instructions is not None:
+                    self._tool_instructions.append(tool.instructions)
+
+            elif callable(tool):
+                try:
+                    function_name = tool.__name__
+
+                    if function_name in _function_names:
+                        continue
+                    _function_names.append(function_name)
+
+                    _func = Function.from_callable(tool, strict=strict)
+                    _func = _func.model_copy(deep=True)
+                    _func._agent = self
+                    if strict:
+                        _func.strict = True
                     if self.tool_hooks is not None:
-                        tool.tool_hooks = self.tool_hooks
-                    _functions.append(tool)
-                    log_debug(f"Added tool {tool.name}")
+                        _func.tool_hooks = self.tool_hooks
+                    _functions.append(_func)
+                    log_debug(f"Added tool {_func.name}")
+                except Exception as e:
+                    log_warning(f"Could not add tool {tool}: {e}")
 
-                    # Add instructions from the Function
-                    if tool.add_instructions and tool.instructions is not None:
-                        self._tool_instructions.append(tool.instructions)
+        return _functions
 
-                elif callable(tool):
-                    try:
-                        function_name = tool.__name__
+    def _determine_tools_for_model(
+        self,
+        model: Model,
+        processed_tools: List[Union[Toolkit, Callable, Function, Dict]],
+        run_response: RunOutput,
+        run_context: RunContext,
+        session: AgentSession,
+        async_mode: bool = False,
+    ) -> List[Union[Function, dict]]:
+        _functions: List[Union[Function, dict]] = []
 
-                        if function_name in _function_names:
-                            continue
-                        _function_names.append(function_name)
-
-                        _func = Function.from_callable(tool, strict=strict)
-                        _func = _func.model_copy(deep=True)
-                        _func._agent = self
-                        if strict:
-                            _func.strict = True
-                        if self.tool_hooks is not None:
-                            _func.tool_hooks = self.tool_hooks
-                        _functions.append(_func)
-                        log_debug(f"Added tool {_func.name}")
-                    except Exception as e:
-                        log_warning(f"Could not add tool {tool}: {e}")
+        # Get Agent tools
+        if processed_tools is not None and len(processed_tools) > 0:
+            log_debug("Processing tools for model")
+            _functions = self._parse_tools(
+                tools=processed_tools, model=model, run_context=run_context, async_mode=async_mode
+            )
 
         # Update the session state for the functions
         if _functions:
@@ -6902,8 +6942,6 @@ class Agent:
             for func in _functions:  # type: ignore
                 if isinstance(func, Function):
                     func._run_context = run_context
-                    func._session_state = run_context.session_state
-                    func._dependencies = run_context.dependencies
                     func._images = joint_images
                     func._files = joint_files
                     func._audios = joint_audios
@@ -7289,6 +7327,647 @@ class Agent:
 
         return agent_session
 
+    # -*- Serialization Functions
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the Agent to a dictionary.
+
+        Returns:
+            Dict[str, Any]: Dictionary representation of the agent configuration
+        """
+        config: Dict[str, Any] = {}
+
+        # --- Agent Settings ---
+        if self.model is not None:
+            if isinstance(self.model, Model):
+                config["model"] = self.model.to_dict()
+            else:
+                config["model"] = str(self.model)
+        if self.name is not None:
+            config["name"] = self.name
+        if self.id is not None:
+            config["id"] = self.id
+
+        # --- User settings ---
+        if self.user_id is not None:
+            config["user_id"] = self.user_id
+
+        # --- Session settings ---
+        if self.session_id is not None:
+            config["session_id"] = self.session_id
+        if self.session_state is not None:
+            config["session_state"] = self.session_state
+        if self.add_session_state_to_context:
+            config["add_session_state_to_context"] = self.add_session_state_to_context
+        if self.enable_agentic_state:
+            config["enable_agentic_state"] = self.enable_agentic_state
+        if self.overwrite_db_session_state:
+            config["overwrite_db_session_state"] = self.overwrite_db_session_state
+        if self.cache_session:
+            config["cache_session"] = self.cache_session
+        if self.search_session_history:
+            config["search_session_history"] = self.search_session_history
+        if self.num_history_sessions is not None:
+            config["num_history_sessions"] = self.num_history_sessions
+        if self.enable_session_summaries:
+            config["enable_session_summaries"] = self.enable_session_summaries
+        if self.add_session_summary_to_context is not None:
+            config["add_session_summary_to_context"] = self.add_session_summary_to_context
+        # TODO: implement session summary manager serialization
+        # if self.session_summary_manager is not None:
+        #     config["session_summary_manager"] = self.session_summary_manager.to_dict()
+
+        # --- Dependencies ---
+        if self.dependencies is not None:
+            config["dependencies"] = self.dependencies
+        if self.add_dependencies_to_context:
+            config["add_dependencies_to_context"] = self.add_dependencies_to_context
+
+        # --- Agentic Memory settings ---
+        # TODO: implement agentic memory serialization
+        # if self.memory_manager is not None:
+        # config["memory_manager"] = self.memory_manager.to_dict()
+        if self.enable_agentic_memory:
+            config["enable_agentic_memory"] = self.enable_agentic_memory
+        if self.enable_user_memories:
+            config["enable_user_memories"] = self.enable_user_memories
+        if self.add_memories_to_context is not None:
+            config["add_memories_to_context"] = self.add_memories_to_context
+
+        # --- Database settings ---
+        if self.db is not None and hasattr(self.db, "to_dict"):
+            config["db"] = self.db.to_dict()
+
+        # --- History settings ---
+        if self.add_history_to_context:
+            config["add_history_to_context"] = self.add_history_to_context
+        if self.num_history_runs is not None:
+            config["num_history_runs"] = self.num_history_runs
+        if self.num_history_messages is not None:
+            config["num_history_messages"] = self.num_history_messages
+        if self.max_tool_calls_from_history is not None:
+            config["max_tool_calls_from_history"] = self.max_tool_calls_from_history
+
+        # --- Knowledge settings ---
+        # TODO: implement knowledge serialization
+        # if self.knowledge is not None:
+        # config["knowledge"] = self.knowledge.to_dict()
+        if self.knowledge_filters is not None:
+            config["knowledge_filters"] = self.knowledge_filters
+        if self.enable_agentic_knowledge_filters:
+            config["enable_agentic_knowledge_filters"] = self.enable_agentic_knowledge_filters
+        if self.add_knowledge_to_context:
+            config["add_knowledge_to_context"] = self.add_knowledge_to_context
+        # Skip knowledge_retriever as it's a callable
+        if self.references_format != "json":
+            config["references_format"] = self.references_format
+
+        # --- Tools ---
+        # Serialize tools to their dictionary representations
+        _tools: List[Union[Function, dict]] = []
+        if self.model is not None:
+            _tools = self._parse_tools(
+                model=self.model,
+                tools=self.tools or [],
+            )
+        if _tools:
+            serialized_tools = []
+            for tool in _tools:
+                try:
+                    if isinstance(tool, Function):
+                        serialized_tools.append(tool.to_dict())
+                    else:
+                        serialized_tools.append(tool)
+                except Exception as e:
+                    # Skip tools that can't be serialized
+                    from agno.utils.log import log_warning
+
+                    log_warning(f"Could not serialize tool {tool}: {e}")
+            if serialized_tools:
+                config["tools"] = serialized_tools
+
+        if self.tool_call_limit is not None:
+            config["tool_call_limit"] = self.tool_call_limit
+        if self.tool_choice is not None:
+            config["tool_choice"] = self.tool_choice
+
+        # --- Reasoning settings ---
+        if self.reasoning:
+            config["reasoning"] = self.reasoning
+        if self.reasoning_model is not None:
+            if isinstance(self.reasoning_model, Model):
+                config["reasoning_model"] = self.reasoning_model.to_dict()
+            else:
+                config["reasoning_model"] = str(self.reasoning_model)
+        # Skip reasoning_agent to avoid circular serialization
+        if self.reasoning_min_steps != 1:
+            config["reasoning_min_steps"] = self.reasoning_min_steps
+        if self.reasoning_max_steps != 10:
+            config["reasoning_max_steps"] = self.reasoning_max_steps
+
+        # --- Default tools settings ---
+        if self.read_chat_history:
+            config["read_chat_history"] = self.read_chat_history
+        if not self.search_knowledge:
+            config["search_knowledge"] = self.search_knowledge
+        if self.update_knowledge:
+            config["update_knowledge"] = self.update_knowledge
+        if self.read_tool_call_history:
+            config["read_tool_call_history"] = self.read_tool_call_history
+        if not self.send_media_to_model:
+            config["send_media_to_model"] = self.send_media_to_model
+        if not self.store_media:
+            config["store_media"] = self.store_media
+        if not self.store_tool_messages:
+            config["store_tool_messages"] = self.store_tool_messages
+        if not self.store_history_messages:
+            config["store_history_messages"] = self.store_history_messages
+
+        # --- System message settings ---
+        # Skip system_message if it's a callable or Message object
+        # TODO: Support Message objects
+        if self.system_message is not None and isinstance(self.system_message, str):
+            config["system_message"] = self.system_message
+        if self.system_message_role != "system":
+            config["system_message_role"] = self.system_message_role
+        if not self.build_context:
+            config["build_context"] = self.build_context
+
+        # --- Context building settings ---
+        if self.description is not None:
+            config["description"] = self.description
+        # Handle instructions (can be str, list, or callable)
+        if self.instructions is not None:
+            if isinstance(self.instructions, str):
+                config["instructions"] = self.instructions
+            elif isinstance(self.instructions, list):
+                config["instructions"] = self.instructions
+            # Skip if callable
+        if self.expected_output is not None:
+            config["expected_output"] = self.expected_output
+        if self.additional_context is not None:
+            config["additional_context"] = self.additional_context
+        if self.markdown:
+            config["markdown"] = self.markdown
+        if self.add_name_to_context:
+            config["add_name_to_context"] = self.add_name_to_context
+        if self.add_datetime_to_context:
+            config["add_datetime_to_context"] = self.add_datetime_to_context
+        if self.add_location_to_context:
+            config["add_location_to_context"] = self.add_location_to_context
+        if self.timezone_identifier is not None:
+            config["timezone_identifier"] = self.timezone_identifier
+        if not self.resolve_in_context:
+            config["resolve_in_context"] = self.resolve_in_context
+
+        # --- Additional input ---
+        # Skip additional_input as it may contain complex Message objects
+        # TODO: Support Message objects
+
+        # --- User message settings ---
+        if self.user_message_role != "user":
+            config["user_message_role"] = self.user_message_role
+        if not self.build_user_context:
+            config["build_user_context"] = self.build_user_context
+
+        # --- Response settings ---
+        if self.retries > 0:
+            config["retries"] = self.retries
+        if self.delay_between_retries != 1:
+            config["delay_between_retries"] = self.delay_between_retries
+        if self.exponential_backoff:
+            config["exponential_backoff"] = self.exponential_backoff
+
+        # --- Schema settings ---
+        if self.input_schema is not None:
+            if isinstance(self.input_schema, type) and issubclass(self.input_schema, BaseModel):
+                config["input_schema"] = self.input_schema.__name__
+            elif isinstance(self.input_schema, dict):
+                config["input_schema"] = self.input_schema
+        if self.output_schema is not None:
+            if isinstance(self.output_schema, type) and issubclass(self.output_schema, BaseModel):
+                config["output_schema"] = self.output_schema.__name__
+            elif isinstance(self.output_schema, dict):
+                config["output_schema"] = self.output_schema
+
+        # --- Parser and output settings ---
+        if self.parser_model is not None:
+            if isinstance(self.parser_model, Model):
+                config["parser_model"] = self.parser_model.to_dict()
+            else:
+                config["parser_model"] = str(self.parser_model)
+        if self.parser_model_prompt is not None:
+            config["parser_model_prompt"] = self.parser_model_prompt
+        if self.output_model is not None:
+            if isinstance(self.output_model, Model):
+                config["output_model"] = self.output_model.to_dict()
+            else:
+                config["output_model"] = str(self.output_model)
+        if self.output_model_prompt is not None:
+            config["output_model_prompt"] = self.output_model_prompt
+        if not self.parse_response:
+            config["parse_response"] = self.parse_response
+        if self.structured_outputs is not None:
+            config["structured_outputs"] = self.structured_outputs
+        if self.use_json_mode:
+            config["use_json_mode"] = self.use_json_mode
+        if self.save_response_to_file is not None:
+            config["save_response_to_file"] = self.save_response_to_file
+
+        # --- Streaming settings ---
+        if self.stream is not None:
+            config["stream"] = self.stream
+        if self.stream_events is not None:
+            config["stream_events"] = self.stream_events
+        if self.store_events:
+            config["store_events"] = self.store_events
+        # Skip events_to_skip as it contains RunEvent enums
+
+        # --- Role and culture settings ---
+        if self.role is not None:
+            config["role"] = self.role
+        # --- Team and workflow settings ---
+        if self.team_id is not None:
+            config["team_id"] = self.team_id
+        if self.workflow_id is not None:
+            config["workflow_id"] = self.workflow_id
+
+        # --- Metadata ---
+        if self.metadata is not None:
+            config["metadata"] = self.metadata
+
+        # --- Context compression settings ---
+        if self.compress_tool_results:
+            config["compress_tool_results"] = self.compress_tool_results
+        # TODO: implement compression manager serialization
+        # if self.compression_manager is not None:
+        #     config["compression_manager"] = self.compression_manager.to_dict()
+
+        # --- Debug and telemetry settings ---
+        if self.debug_mode:
+            config["debug_mode"] = self.debug_mode
+        if self.debug_level != 1:
+            config["debug_level"] = self.debug_level
+        if not self.telemetry:
+            config["telemetry"] = self.telemetry
+
+        return config
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any], registry: Optional[Registry] = None) -> "Agent":
+        """
+        Create an agent from a dictionary.
+
+        Args:
+            data: Dictionary containing agent configuration
+            registry: Optional registry for rehydrating tools and schemas
+
+        Returns:
+            Agent: Reconstructed agent instance
+        """
+        from agno.models.utils import get_model
+
+        config = data.copy()
+
+        # --- Handle Model reconstruction ---
+        if "model" in config:
+            model_data = config["model"]
+            if isinstance(model_data, dict) and "id" in model_data:
+                config["model"] = get_model(f"{model_data['provider']}:{model_data['id']}")
+            elif isinstance(model_data, str):
+                config["model"] = get_model(model_data)
+
+        # --- Handle reasoning_model reconstruction ---
+        # TODO: implement reasoning model deserialization
+        # if "reasoning_model" in config:
+        #     model_data = config["reasoning_model"]
+        #     if isinstance(model_data, dict) and "id" in model_data:
+        #         config["reasoning_model"] = get_model(f"{model_data['provider']}:{model_data['id']}")
+        #     elif isinstance(model_data, str):
+        #         config["reasoning_model"] = get_model(model_data)
+
+        # --- Handle parser_model reconstruction ---
+        # TODO: implement parser model deserialization
+        # if "parser_model" in config:
+        #     model_data = config["parser_model"]
+        #     if isinstance(model_data, dict) and "id" in model_data:
+        #         config["parser_model"] = get_model(f"{model_data['provider']}:{model_data['id']}")
+        #     elif isinstance(model_data, str):
+        #         config["parser_model"] = get_model(model_data)
+
+        # --- Handle output_model reconstruction ---
+        # TODO: implement output model deserialization
+        # if "output_model" in config:
+        #     model_data = config["output_model"]
+        #     if isinstance(model_data, dict) and "id" in model_data:
+        #         config["output_model"] = get_model(f"{model_data['provider']}:{model_data['id']}")
+        #     elif isinstance(model_data, str):
+        #         config["output_model"] = get_model(model_data)
+
+        # --- Handle tools reconstruction ---
+        if "tools" in config and config["tools"]:
+            if registry:
+                config["tools"] = [registry.rehydrate_function(t) for t in config["tools"]]
+            else:
+                log_warning("No registry provided, tools will not be rehydrated.")
+                del config["tools"]
+
+        # --- Handle DB reconstruction ---
+        if "db" in config and isinstance(config["db"], dict):
+            db_data = config["db"]
+            db_id = db_data.get("id")
+
+            # First try to get the db from the registry (preferred - reuses existing connection)
+            if registry and db_id:
+                registry_db = registry.get_db(db_id)
+                if registry_db is not None:
+                    config["db"] = registry_db
+                else:
+                    del config["db"]
+            else:
+                # No registry or no db_id, fall back to creating from dict
+                config["db"] = db_from_dict(db_data)
+                if config["db"] is None:
+                    del config["db"]
+
+        # --- Handle Schema reconstruction ---
+        if "input_schema" in config and isinstance(config["input_schema"], str):
+            schema_cls = registry.get_schema(config["input_schema"]) if registry else None
+            if schema_cls:
+                config["input_schema"] = schema_cls
+            else:
+                log_warning(f"Input schema {config['input_schema']} not found in registry, skipping.")
+                del config["input_schema"]
+
+        if "output_schema" in config and isinstance(config["output_schema"], str):
+            schema_cls = registry.get_schema(config["output_schema"]) if registry else None
+            if schema_cls:
+                config["output_schema"] = schema_cls
+            else:
+                log_warning(f"Output schema {config['output_schema']} not found in registry, skipping.")
+                del config["output_schema"]
+
+        # --- Handle MemoryManager reconstruction ---
+        # TODO: implement memory manager deserialization
+        # if "memory_manager" in config and isinstance(config["memory_manager"], dict):
+        #     from agno.memory import MemoryManager
+        #     config["memory_manager"] = MemoryManager.from_dict(config["memory_manager"])
+
+        # --- Handle SessionSummaryManager reconstruction ---
+        # TODO: implement session summary manager deserialization
+        # if "session_summary_manager" in config and isinstance(config["session_summary_manager"], dict):
+        #     from agno.session import SessionSummaryManager
+        #     config["session_summary_manager"] = SessionSummaryManager.from_dict(config["session_summary_manager"])
+
+        # --- Handle CultureManager reconstruction ---
+        # TODO: implement culture manager deserialization
+        # if "culture_manager" in config and isinstance(config["culture_manager"], dict):
+        #     from agno.culture import CultureManager
+        #     config["culture_manager"] = CultureManager.from_dict(config["culture_manager"])
+
+        # --- Handle Knowledge reconstruction ---
+        # TODO: implement knowledge deserialization
+        # if "knowledge" in config and isinstance(config["knowledge"], dict):
+        #     from agno.knowledge import Knowledge
+        #     config["knowledge"] = Knowledge.from_dict(config["knowledge"])
+
+        # --- Handle CompressionManager reconstruction ---
+        # TODO: implement compression manager deserialization
+        # if "compression_manager" in config and isinstance(config["compression_manager"], dict):
+        #     from agno.compression.manager import CompressionManager
+        #     config["compression_manager"] = CompressionManager.from_dict(config["compression_manager"])
+
+        # Remove keys that aren't constructor parameters
+        config.pop("team_id", None)
+        config.pop("workflow_id", None)
+
+        return cls(
+            # --- Agent settings ---
+            model=config.get("model"),
+            name=config.get("name"),
+            id=config.get("id"),
+            # --- User settings ---
+            user_id=config.get("user_id"),
+            # --- Session settings ---
+            session_id=config.get("session_id"),
+            session_state=config.get("session_state"),
+            add_session_state_to_context=config.get("add_session_state_to_context", False),
+            enable_agentic_state=config.get("enable_agentic_state", False),
+            overwrite_db_session_state=config.get("overwrite_db_session_state", False),
+            cache_session=config.get("cache_session", False),
+            search_session_history=config.get("search_session_history", False),
+            num_history_sessions=config.get("num_history_sessions"),
+            enable_session_summaries=config.get("enable_session_summaries", False),
+            add_session_summary_to_context=config.get("add_session_summary_to_context"),
+            # session_summary_manager=config.get("session_summary_manager"),  # TODO
+            # --- Dependencies ---
+            dependencies=config.get("dependencies"),
+            add_dependencies_to_context=config.get("add_dependencies_to_context", False),
+            # --- Agentic Memory settings ---
+            # memory_manager=config.get("memory_manager"),  # TODO
+            enable_agentic_memory=config.get("enable_agentic_memory", False),
+            enable_user_memories=config.get("enable_user_memories", False),
+            add_memories_to_context=config.get("add_memories_to_context"),
+            # --- Database settings ---
+            db=config.get("db"),
+            # --- History settings ---
+            add_history_to_context=config.get("add_history_to_context", False),
+            num_history_runs=config.get("num_history_runs"),
+            num_history_messages=config.get("num_history_messages"),
+            max_tool_calls_from_history=config.get("max_tool_calls_from_history"),
+            # --- Knowledge settings ---
+            # knowledge=config.get("knowledge"),  # TODO
+            knowledge_filters=config.get("knowledge_filters"),
+            enable_agentic_knowledge_filters=config.get("enable_agentic_knowledge_filters", False),
+            add_knowledge_to_context=config.get("add_knowledge_to_context", False),
+            references_format=config.get("references_format", "json"),
+            # --- Tools ---
+            tools=config.get("tools"),
+            tool_call_limit=config.get("tool_call_limit"),
+            tool_choice=config.get("tool_choice"),
+            # --- Reasoning settings ---
+            reasoning=config.get("reasoning", False),
+            # reasoning_model=config.get("reasoning_model"),  # TODO
+            reasoning_min_steps=config.get("reasoning_min_steps", 1),
+            reasoning_max_steps=config.get("reasoning_max_steps", 10),
+            # --- Default tools settings ---
+            read_chat_history=config.get("read_chat_history", False),
+            search_knowledge=config.get("search_knowledge", True),
+            update_knowledge=config.get("update_knowledge", False),
+            read_tool_call_history=config.get("read_tool_call_history", False),
+            send_media_to_model=config.get("send_media_to_model", True),
+            store_media=config.get("store_media", True),
+            store_tool_messages=config.get("store_tool_messages", True),
+            store_history_messages=config.get("store_history_messages", True),
+            # --- System message settings ---
+            system_message=config.get("system_message"),
+            system_message_role=config.get("system_message_role", "system"),
+            build_context=config.get("build_context", True),
+            # --- Context building settings ---
+            description=config.get("description"),
+            instructions=config.get("instructions"),
+            expected_output=config.get("expected_output"),
+            additional_context=config.get("additional_context"),
+            markdown=config.get("markdown", False),
+            add_name_to_context=config.get("add_name_to_context", False),
+            add_datetime_to_context=config.get("add_datetime_to_context", False),
+            add_location_to_context=config.get("add_location_to_context", False),
+            timezone_identifier=config.get("timezone_identifier"),
+            resolve_in_context=config.get("resolve_in_context", True),
+            # --- User message settings ---
+            user_message_role=config.get("user_message_role", "user"),
+            build_user_context=config.get("build_user_context", True),
+            # --- Response settings ---
+            retries=config.get("retries", 0),
+            delay_between_retries=config.get("delay_between_retries", 1),
+            exponential_backoff=config.get("exponential_backoff", False),
+            # --- Schema settings ---
+            input_schema=config.get("input_schema"),
+            output_schema=config.get("output_schema"),
+            # --- Parser and output settings ---
+            # parser_model=config.get("parser_model"),  # TODO
+            parser_model_prompt=config.get("parser_model_prompt"),
+            # output_model=config.get("output_model"),  # TODO
+            output_model_prompt=config.get("output_model_prompt"),
+            parse_response=config.get("parse_response", True),
+            structured_outputs=config.get("structured_outputs"),
+            use_json_mode=config.get("use_json_mode", False),
+            save_response_to_file=config.get("save_response_to_file"),
+            # --- Streaming settings ---
+            stream=config.get("stream"),
+            stream_events=config.get("stream_events"),
+            store_events=config.get("store_events", False),
+            role=config.get("role"),
+            # --- Culture settings ---
+            # culture_manager=config.get("culture_manager"),  # TODO
+            # --- Metadata ---
+            metadata=config.get("metadata"),
+            # --- Compression settings ---
+            compress_tool_results=config.get("compress_tool_results", False),
+            # compression_manager=config.get("compression_manager"),  # TODO
+            # --- Debug and telemetry settings ---
+            debug_mode=config.get("debug_mode", False),
+            debug_level=config.get("debug_level", 1),
+            telemetry=config.get("telemetry", True),
+        )
+
+    # -*- Component and Config Functions
+    def save(
+        self,
+        *,
+        db: Optional["BaseDb"] = None,
+        stage: str = "published",
+        label: Optional[str] = None,
+        notes: Optional[str] = None,
+    ) -> Optional[int]:
+        """
+        Save the agent component and config.
+
+        Args:
+            db: The database to save the component and config to.
+            stage: The stage of the component. Defaults to "published".
+            label: The label of the component.
+            notes: The notes of the component.
+
+        Returns:
+            Optional[int]: The version number of the saved config.
+        """
+        db_ = db or self.db
+        if not db_:
+            raise ValueError("Db not initialized or provided")
+        if not isinstance(db_, BaseDb):
+            raise ValueError("Async databases not yet supported for save(). Use a sync database.")
+
+        if self.id is None:
+            self.id = generate_id_from_name(self.name)
+
+        try:
+            # Create or update component
+            db_.upsert_component(
+                component_id=self.id,
+                component_type=ComponentType.AGENT,
+                name=getattr(self, "name", self.id),
+                description=getattr(self, "description", None),
+                metadata=getattr(self, "metadata", None),
+            )
+
+            # Create or update config
+            config = db_.upsert_config(
+                component_id=self.id,
+                config=self.to_dict(),
+                label=label,
+                stage=stage,
+                notes=notes,
+            )
+
+            return config.get("version")
+
+        except Exception as e:
+            log_error(f"Error saving Agent to database: {e}")
+            raise
+
+    @classmethod
+    def load(
+        cls,
+        id: str,
+        *,
+        db: "BaseDb",
+        registry: Optional["Registry"] = None,
+        label: Optional[str] = None,
+        version: Optional[int] = None,
+    ) -> Optional["Agent"]:
+        """
+        Load an agent by id.
+
+        Args:
+            id: The id of the agent to load.
+            db: The database to load the agent from.
+            label: The label of the agent to load.
+
+        Returns:
+            The agent loaded from the database or None if not found.
+        """
+
+        data = db.get_config(component_id=id, label=label, version=version)
+        if data is None:
+            return None
+
+        config = data.get("config")
+        if config is None:
+            return None
+
+        agent = cls.from_dict(config, registry=registry)
+        agent.id = id
+        agent.db = db
+
+        return agent
+
+    def delete(
+        self,
+        *,
+        db: Optional["BaseDb"] = None,
+        hard_delete: bool = False,
+    ) -> bool:
+        """
+        Delete the agent component.
+
+        Args:
+            db: The database to delete the component from.
+            hard_delete: Whether to hard delete the component.
+
+        Returns:
+            True if the component was deleted, False otherwise.
+        """
+        db_ = db or self.db
+        if not db_:
+            raise ValueError("Db not initialized or provided")
+        if not isinstance(db_, BaseDb):
+            raise ValueError("Async databases not yet supported for delete(). Use a sync database.")
+        if self.id is None:
+            raise ValueError("Cannot delete agent without an id")
+
+        return db_.delete_component(component_id=self.id, hard_delete=hard_delete)
+
     # -*- Public Convenience Functions
     def get_run_output(self, run_id: str, session_id: Optional[str] = None) -> Optional[RunOutput]:
         """
@@ -8009,12 +8688,9 @@ class Agent:
     def _format_message_with_state_variables(
         self,
         message: Any,
-        session_state: Optional[Dict[str, Any]] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-        user_id: Optional[str] = None,
+        run_context: Optional[RunContext] = None,
     ) -> Any:
-        """Format a message with the session state variables."""
+        """Format a message with the session state variables from run_context."""
         import re
         import string
         from copy import deepcopy
@@ -8022,6 +8698,12 @@ class Agent:
         if not isinstance(message, str):
             return message
 
+        # Extract values from run_context
+        session_state = run_context.session_state if run_context else None
+        dependencies = run_context.dependencies if run_context else None
+        metadata = run_context.metadata if run_context else None
+        user_id = run_context.user_id if run_context else None
+
         # Should already be resolved and passed from run() method
         format_variables = ChainMap(
             session_state if session_state is not None else {},
@@ -8050,12 +8732,8 @@ class Agent:
         self,
         session: AgentSession,
         run_context: Optional[RunContext] = None,
-        user_id: Optional[str] = None,
         tools: Optional[List[Union[Function, dict]]] = None,
         add_session_state_to_context: Optional[bool] = None,
-        session_state: Optional[Dict[str, Any]] = None,  # Deprecated
-        dependencies: Optional[Dict[str, Any]] = None,  # Deprecated
-        metadata: Optional[Dict[str, Any]] = None,  # Deprecated
     ) -> Optional[Message]:
         """Return the system message for the Agent.
 
@@ -8064,11 +8742,9 @@ class Agent:
         3. Build and return the default system message for the Agent.
         """
 
-        # Consider both run_context and session_state, dependencies, metadata (deprecated fields)
-        if run_context is not None:
-            session_state = run_context.session_state or session_state
-            dependencies = run_context.dependencies or dependencies
-            metadata = run_context.metadata or metadata
+        # Extract values from run_context
+        session_state = run_context.session_state if run_context else None
+        user_id = run_context.user_id if run_context else None
 
         # Get output_schema from run_context
         output_schema = run_context.output_schema if run_context else None
@@ -8091,10 +8767,7 @@ class Agent:
             if self.resolve_in_context:
                 sys_message_content = self._format_message_with_state_variables(
                     sys_message_content,
-                    user_id=user_id,
-                    session_state=session_state,
-                    dependencies=dependencies,
-                    metadata=metadata,
+                    run_context=run_context,
                 )
 
             # type: ignore
@@ -8173,32 +8846,15 @@ class Agent:
         if self.name is not None and self.add_name_to_context:
             additional_information.append(f"Your name is: {self.name}.")
 
-        # 3.2.5 Add information about agentic filters if enabled
-        if self.knowledge is not None and self.enable_agentic_knowledge_filters:
-            valid_filters = self.knowledge.get_valid_filters()
-            if valid_filters:
-                valid_filters_str = ", ".join(valid_filters)
-                additional_information.append(
-                    dedent(
-                        f"""
-                    The knowledge base contains documents with these metadata filters: {valid_filters_str}.
-                    Always use filters when the user query indicates specific metadata.
-
-                    Examples:
-                    1. If the user asks about a specific person like "Jordan Mitchell", you MUST use the search_knowledge_base tool with the filters parameter set to {{'<valid key like user_id>': '<valid value based on the user query>'}}.
-                    2. If the user asks about a specific document type like "contracts", you MUST use the search_knowledge_base tool with the filters parameter set to {{'document_type': 'contract'}}.
-                    4. If the user asks about a specific location like "documents from New York", you MUST use the search_knowledge_base tool with the filters parameter set to {{'<valid key like location>': 'New York'}}.
-
-                    General Guidelines:
-                    - Always analyze the user query to identify relevant metadata.
-                    - Use the most specific filter(s) possible to narrow down results.
-                    - If multiple filters are relevant, combine them in the filters parameter (e.g., {{'name': 'Jordan Mitchell', 'document_type': 'contract'}}).
-                    - Ensure the filter keys match the valid metadata filters: {valid_filters_str}.
-
-                    You can use the search_knowledge_base tool to search the knowledge base and get the most relevant documents. Make sure to pass the filters as [Dict[str: Any]] to the tool. FOLLOW THIS STRUCTURE STRICTLY.
-                """
-                    )
+        # 3.2.5 Add knowledge context using protocol's build_context
+        if self.knowledge is not None:
+            build_context_fn = getattr(self.knowledge, "build_context", None)
+            if callable(build_context_fn):
+                knowledge_context = build_context_fn(
+                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
                 )
+                if knowledge_context:
+                    additional_information.append(knowledge_context)
 
         # 3.3 Build the default system message for the Agent.
         system_message_content: str = ""
@@ -8208,22 +8864,29 @@ class Agent:
         # 3.3.2 Then add the Agent role if provided
         if self.role is not None:
             system_message_content += f"\n<your_role>\n{self.role}\n</your_role>\n\n"
-        # 3.3.4 Then add instructions for the Agent
+        # 3.3.3 Then add instructions for the Agent
         if len(instructions) > 0:
-            system_message_content += "<instructions>"
-            if len(instructions) > 1:
-                for _upi in instructions:
-                    system_message_content += f"\n- {_upi}"
+            if self.use_instruction_tags:
+                system_message_content += "<instructions>"
+                if len(instructions) > 1:
+                    for _upi in instructions:
+                        system_message_content += f"\n- {_upi}"
+                else:
+                    system_message_content += "\n" + instructions[0]
+                system_message_content += "\n</instructions>\n\n"
             else:
-                system_message_content += "\n" + instructions[0]
-            system_message_content += "\n</instructions>\n\n"
-        # 3.3.6 Add additional information
+                if len(instructions) > 1:
+                    for _upi in instructions:
+                        system_message_content += f"- {_upi}\n"
+                else:
+                    system_message_content += instructions[0] + "\n\n"
+        # 3.3.4 Add additional information
         if len(additional_information) > 0:
             system_message_content += "<additional_information>"
             for _ai in additional_information:
                 system_message_content += f"\n- {_ai}"
             system_message_content += "\n</additional_information>\n\n"
-        # 3.3.7 Then add instructions for the tools
+        # 3.3.5 Then add instructions for the tools
         if self._tool_instructions is not None:
             for _ti in self._tool_instructions:
                 system_message_content += f"{_ti}\n"
@@ -8232,10 +8895,7 @@ class Agent:
         if self.resolve_in_context:
             system_message_content = self._format_message_with_state_variables(
                 system_message_content,
-                user_id=user_id,
-                session_state=session_state,
-                dependencies=dependencies,
-                metadata=metadata,
+                run_context=run_context,
             )
 
         # 3.3.7 Then add the expected output
@@ -8408,12 +9068,8 @@ class Agent:
         self,
         session: AgentSession,
         run_context: Optional[RunContext] = None,
-        user_id: Optional[str] = None,
         tools: Optional[List[Union[Function, dict]]] = None,
         add_session_state_to_context: Optional[bool] = None,
-        session_state: Optional[Dict[str, Any]] = None,  # Deprecated
-        dependencies: Optional[Dict[str, Any]] = None,  # Deprecated
-        metadata: Optional[Dict[str, Any]] = None,  # Deprecated
     ) -> Optional[Message]:
         """Return the system message for the Agent.
 
@@ -8422,11 +9078,9 @@ class Agent:
         3. Build and return the default system message for the Agent.
         """
 
-        # Consider both run_context and session_state, dependencies, metadata (deprecated fields)
-        if run_context is not None:
-            session_state = run_context.session_state or session_state
-            dependencies = run_context.dependencies or dependencies
-            metadata = run_context.metadata or metadata
+        # Extract values from run_context
+        session_state = run_context.session_state if run_context else None
+        user_id = run_context.user_id if run_context else None
 
         # Get output_schema from run_context
         output_schema = run_context.output_schema if run_context else None
@@ -8450,10 +9104,7 @@ class Agent:
             if self.resolve_in_context:
                 sys_message_content = self._format_message_with_state_variables(
                     sys_message_content,
-                    user_id=user_id,
-                    dependencies=dependencies,
-                    metadata=metadata,
-                    session_state=session_state,
+                    run_context=run_context,
                 )
 
             # type: ignore
@@ -8532,32 +9183,23 @@ class Agent:
         if self.name is not None and self.add_name_to_context:
             additional_information.append(f"Your name is: {self.name}.")
 
-        # 3.2.5 Add information about agentic filters if enabled
-        if self.knowledge is not None and self.enable_agentic_knowledge_filters:
-            valid_filters = await self.knowledge.async_get_valid_filters()
-            if valid_filters:
-                valid_filters_str = ", ".join(valid_filters)
-                additional_information.append(
-                    dedent(
-                        f"""
-                    The knowledge base contains documents with these metadata filters: {valid_filters_str}.
-                    Always use filters when the user query indicates specific metadata.
-
-                    Examples:
-                    1. If the user asks about a specific person like "Jordan Mitchell", you MUST use the search_knowledge_base tool with the filters parameter set to {{'<valid key like user_id>': '<valid value based on the user query>'}}.
-                    2. If the user asks about a specific document type like "contracts", you MUST use the search_knowledge_base tool with the filters parameter set to {{'document_type': 'contract'}}.
-                    4. If the user asks about a specific location like "documents from New York", you MUST use the search_knowledge_base tool with the filters parameter set to {{'<valid key like location>': 'New York'}}.
-
-                    General Guidelines:
-                    - Always analyze the user query to identify relevant metadata.
-                    - Use the most specific filter(s) possible to narrow down results.
-                    - If multiple filters are relevant, combine them in the filters parameter (e.g., {{'name': 'Jordan Mitchell', 'document_type': 'contract'}}).
-                    - Ensure the filter keys match the valid metadata filters: {valid_filters_str}.
-
-                    You can use the search_knowledge_base tool to search the knowledge base and get the most relevant documents. Make sure to pass the filters as [Dict[str: Any]] to the tool. FOLLOW THIS STRUCTURE STRICTLY.
-                """
-                    )
+        # 3.2.5 Add knowledge context using protocol's build_context (async)
+        if self.knowledge is not None:
+            # Prefer async version if available for async databases
+            abuild_context_fn = getattr(self.knowledge, "abuild_context", None)
+            build_context_fn = getattr(self.knowledge, "build_context", None)
+            if callable(abuild_context_fn):
+                knowledge_context = await abuild_context_fn(
+                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
+                )
+                if knowledge_context:
+                    additional_information.append(knowledge_context)
+            elif callable(build_context_fn):
+                knowledge_context = build_context_fn(
+                    enable_agentic_filters=self.enable_agentic_knowledge_filters,
                 )
+                if knowledge_context:
+                    additional_information.append(knowledge_context)
 
         # 3.3 Build the default system message for the Agent.
         system_message_content: str = ""
@@ -8567,22 +9209,29 @@ class Agent:
         # 3.3.2 Then add the Agent role if provided
         if self.role is not None:
             system_message_content += f"\n<your_role>\n{self.role}\n</your_role>\n\n"
-        # 3.3.4 Then add instructions for the Agent
+        # 3.3.3 Then add instructions for the Agent
         if len(instructions) > 0:
-            system_message_content += "<instructions>"
-            if len(instructions) > 1:
-                for _upi in instructions:
-                    system_message_content += f"\n- {_upi}"
+            if self.use_instruction_tags:
+                system_message_content += "<instructions>"
+                if len(instructions) > 1:
+                    for _upi in instructions:
+                        system_message_content += f"\n- {_upi}"
+                else:
+                    system_message_content += "\n" + instructions[0]
+                system_message_content += "\n</instructions>\n\n"
             else:
-                system_message_content += "\n" + instructions[0]
-            system_message_content += "\n</instructions>\n\n"
-        # 3.3.6 Add additional information
+                if len(instructions) > 1:
+                    for _upi in instructions:
+                        system_message_content += f"- {_upi}\n"
+                else:
+                    system_message_content += instructions[0] + "\n\n"
+        # 3.3.4 Add additional information
         if len(additional_information) > 0:
             system_message_content += "<additional_information>"
             for _ai in additional_information:
                 system_message_content += f"\n- {_ai}"
             system_message_content += "\n</additional_information>\n\n"
-        # 3.3.7 Then add instructions for the tools
+        # 3.3.5 Then add instructions for the tools
         if self._tool_instructions is not None:
             for _ti in self._tool_instructions:
                 system_message_content += f"{_ti}\n"
@@ -8591,10 +9240,7 @@ class Agent:
         if self.resolve_in_context:
             system_message_content = self._format_message_with_state_variables(
                 system_message_content,
-                user_id=user_id,
-                session_state=session_state,
-                dependencies=dependencies,
-                metadata=metadata,
+                run_context=run_context,
             )
 
         # 3.3.7 Then add the expected output
@@ -8774,17 +9420,12 @@ class Agent:
         *,
         run_response: RunOutput,
         run_context: Optional[RunContext] = None,
-        session_state: Optional[Dict[str, Any]] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-        user_id: Optional[str] = None,
         input: Optional[Union[str, List, Dict, Message, BaseModel, List[Message]]] = None,
         audio: Optional[Sequence[Audio]] = None,
         images: Optional[Sequence[Image]] = None,
         videos: Optional[Sequence[Video]] = None,
         files: Optional[Sequence[File]] = None,
         add_dependencies_to_context: Optional[bool] = None,
-        knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
         **kwargs: Any,
     ) -> Optional[Message]:
         """Return the user message for the Agent.
@@ -8793,12 +9434,9 @@ class Agent:
         2. If build_user_context is False or if the message is a list, return the message as is.
         3. Build the default user message for the Agent
         """
-        # Consider both run_context and session_state, dependencies, metadata, knowledge_filters (deprecated fields)
-        if run_context is not None:
-            session_state = run_context.session_state or session_state
-            dependencies = run_context.dependencies or dependencies
-            metadata = run_context.metadata or metadata
-            knowledge_filters = run_context.knowledge_filters or knowledge_filters
+        # Extract values from run_context
+        dependencies = run_context.dependencies if run_context else None
+        knowledge_filters = run_context.knowledge_filters if run_context else None
         # Get references from the knowledge base to use in the user message
         references = None
 
@@ -8903,10 +9541,7 @@ class Agent:
                 if self.resolve_in_context:
                     user_msg_content = self._format_message_with_state_variables(
                         user_msg_content,
-                        user_id=user_id,
-                        session_state=session_state,
-                        dependencies=dependencies,
-                        metadata=metadata,
+                        run_context=run_context,
                     )
 
                 # Convert to string for concatenation operations
@@ -8948,17 +9583,12 @@ class Agent:
         *,
         run_response: RunOutput,
         run_context: Optional[RunContext] = None,
-        session_state: Optional[Dict[str, Any]] = None,
-        dependencies: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-        user_id: Optional[str] = None,
         input: Optional[Union[str, List, Dict, Message, BaseModel, List[Message]]] = None,
         audio: Optional[Sequence[Audio]] = None,
         images: Optional[Sequence[Image]] = None,
         videos: Optional[Sequence[Video]] = None,
         files: Optional[Sequence[File]] = None,
         add_dependencies_to_context: Optional[bool] = None,
-        knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None,
         **kwargs: Any,
     ) -> Optional[Message]:
         """Return the user message for the Agent (async version).
@@ -8967,12 +9597,9 @@ class Agent:
         2. If build_user_context is False or if the message is a list, return the message as is.
         3. Build the default user message for the Agent
         """
-        # Consider both run_context and session_state, dependencies, metadata, knowledge_filters (deprecated fields)
-        if run_context is not None:
-            session_state = run_context.session_state or session_state
-            dependencies = run_context.dependencies or dependencies
-            metadata = run_context.metadata or metadata
-            knowledge_filters = run_context.knowledge_filters or knowledge_filters
+        # Extract values from run_context
+        dependencies = run_context.dependencies if run_context else None
+        knowledge_filters = run_context.knowledge_filters if run_context else None
         # Get references from the knowledge base to use in the user message
         references = None
 
@@ -9077,10 +9704,7 @@ class Agent:
                 if self.resolve_in_context:
                     user_msg_content = self._format_message_with_state_variables(
                         user_msg_content,
-                        user_id=user_id,
-                        session_state=session_state,
-                        dependencies=dependencies,
-                        metadata=metadata,
+                        run_context=run_context,
                     )
 
                 # Convert to string for concatenation operations
@@ -9166,10 +9790,6 @@ class Agent:
         system_message = self.get_system_message(
             session=session,
             run_context=run_context,
-            session_state=run_context.session_state,
-            dependencies=run_context.dependencies,
-            metadata=run_context.metadata,
-            user_id=user_id,
             tools=tools,
             add_session_state_to_context=add_session_state_to_context,
         )
@@ -9366,12 +9986,6 @@ class Agent:
         )
         """
 
-        # Consider both run_context and session_state, dependencies, metadata (deprecated fields)
-        if run_context is not None:
-            session_state = run_context.session_state or session_state
-            dependencies = run_context.dependencies or dependencies
-            metadata = run_context.metadata or metadata
-
         # Initialize the RunMessages object (no media here - that's in RunInput now)
         run_messages = RunMessages()
 
@@ -9379,11 +9993,7 @@ class Agent:
         system_message = await self.aget_system_message(
             session=session,
             run_context=run_context,
-            session_state=session_state,
-            user_id=user_id,
             tools=tools,
-            dependencies=dependencies,
-            metadata=metadata,
             add_session_state_to_context=add_session_state_to_context,
         )
         if system_message is not None:
@@ -9469,15 +10079,11 @@ class Agent:
             user_message = await self._aget_user_message(
                 run_response=run_response,
                 run_context=run_context,
-                session_state=session_state,
-                dependencies=dependencies,
-                metadata=metadata,
                 input=input,
                 audio=audio,
                 images=images,
                 videos=videos,
                 files=files,
-                knowledge_filters=knowledge_filters,
                 add_dependencies_to_context=add_dependencies_to_context,
                 **kwargs,
             )
@@ -9660,7 +10266,7 @@ class Agent:
         dependencies = run_context.dependencies if run_context else None
 
         if num_documents is None and self.knowledge is not None:
-            num_documents = self.knowledge.max_results
+            num_documents = getattr(self.knowledge, "max_results", None)
         # Validate the filters against known valid filter keys
         if self.knowledge is not None and filters is not None:
             if validate_filters:
@@ -9701,22 +10307,22 @@ class Agent:
                 log_warning(f"Knowledge retriever failed: {e}")
                 raise e
 
-        # Use knowledge base search
+        # Use knowledge protocol's retrieve method
         try:
-            if self.knowledge is None or (
-                (getattr(self.knowledge, "vector_db", None)) is None
-                and getattr(self.knowledge, "knowledge_retriever", None) is None
-            ):
+            if self.knowledge is None:
+                return None
+
+            # Use protocol retrieve() method if available
+            retrieve_fn = getattr(self.knowledge, "retrieve", None)
+            if not callable(retrieve_fn):
+                log_debug("Knowledge does not implement retrieve()")
                 return None
 
             if num_documents is None:
-                if isinstance(self.knowledge, Knowledge):
-                    num_documents = self.knowledge.max_results
+                num_documents = getattr(self.knowledge, "max_results", 10)
 
-            log_debug(f"Searching knowledge base with filters: {filters}")
-            relevant_docs: List[Document] = self.knowledge.search(
-                query=query, max_results=num_documents, filters=filters
-            )
+            log_debug(f"Retrieving from knowledge base with filters: {filters}")
+            relevant_docs: List[Document] = retrieve_fn(query=query, max_results=num_documents, filters=filters)
 
             if not relevant_docs or len(relevant_docs) == 0:
                 log_debug("No relevant documents found for query")
@@ -9724,7 +10330,7 @@ class Agent:
 
             return [doc.to_dict() for doc in relevant_docs]
         except Exception as e:
-            log_warning(f"Error searching knowledge base: {e}")
+            log_warning(f"Error retrieving from knowledge base: {e}")
             raise e
 
     async def aget_relevant_docs_from_knowledge(
@@ -9743,12 +10349,12 @@ class Agent:
         dependencies = run_context.dependencies if run_context else None
 
         if num_documents is None and self.knowledge is not None:
-            num_documents = self.knowledge.max_results
+            num_documents = getattr(self.knowledge, "max_results", None)
 
         # Validate the filters against known valid filter keys
         if self.knowledge is not None and filters is not None:
             if validate_filters:
-                valid_filters, invalid_keys = await self.knowledge.async_validate_filters(filters)  # type: ignore
+                valid_filters, invalid_keys = await self.knowledge.avalidate_filters(filters)  # type: ignore
 
                 # Warn about invalid filter keys
                 if invalid_keys:  # type: ignore
@@ -9789,21 +10395,32 @@ class Agent:
                 log_warning(f"Knowledge retriever failed: {e}")
                 raise e
 
-        # Use knowledge base search
+        # Use knowledge protocol's retrieve method
         try:
-            if self.knowledge is None or (
-                getattr(self.knowledge, "vector_db", None) is None
-                and getattr(self.knowledge, "knowledge_retriever", None) is None
-            ):
+            if self.knowledge is None:
+                return None
+
+            # Use protocol aretrieve() or retrieve() method if available
+            aretrieve_fn = getattr(self.knowledge, "aretrieve", None)
+            retrieve_fn = getattr(self.knowledge, "retrieve", None)
+
+            if not callable(aretrieve_fn) and not callable(retrieve_fn):
+                log_debug("Knowledge does not implement retrieve()")
                 return None
 
             if num_documents is None:
-                num_documents = self.knowledge.max_results
+                num_documents = getattr(self.knowledge, "max_results", 10)
 
-            log_debug(f"Searching knowledge base with filters: {filters}")
-            relevant_docs: List[Document] = await self.knowledge.async_search(
-                query=query, max_results=num_documents, filters=filters
-            )
+            log_debug(f"Retrieving from knowledge base with filters: {filters}")
+
+            if callable(aretrieve_fn):
+                relevant_docs: List[Document] = await aretrieve_fn(
+                    query=query, max_results=num_documents, filters=filters
+                )
+            elif callable(retrieve_fn):
+                relevant_docs = retrieve_fn(query=query, max_results=num_documents, filters=filters)
+            else:
+                return None
 
             if not relevant_docs or len(relevant_docs) == 0:
                 log_debug("No relevant documents found for query")
@@ -9811,7 +10428,7 @@ class Agent:
 
             return [doc.to_dict() for doc in relevant_docs]
         except Exception as e:
-            log_warning(f"Error searching knowledge base: {e}")
+            log_warning(f"Error retrieving from knowledge base: {e}")
             raise e
 
     def _convert_documents_to_string(self, docs: List[Union[Dict[str, Any], str]]) -> str:
@@ -9877,18 +10494,30 @@ class Agent:
         fields_for_new_agent: Dict[str, Any] = {}
 
         for f in fields(self):
+            # Skip private fields (not part of __init__ signature)
+            if f.name.startswith("_"):
+                continue
+
             field_value = getattr(self, f.name)
             if field_value is not None:
-                fields_for_new_agent[f.name] = self._deep_copy_field(f.name, field_value)
+                try:
+                    fields_for_new_agent[f.name] = self._deep_copy_field(f.name, field_value)
+                except Exception as e:
+                    log_warning(f"Failed to deep copy field '{f.name}': {e}. Using original value.")
+                    fields_for_new_agent[f.name] = field_value
 
         # Update fields if provided
         if update:
             fields_for_new_agent.update(update)
 
         # Create a new Agent
-        new_agent = self.__class__(**fields_for_new_agent)
-        log_debug(f"Created new {self.__class__.__name__}")
-        return new_agent
+        try:
+            new_agent = self.__class__(**fields_for_new_agent)
+            log_debug(f"Created new {self.__class__.__name__}")
+            return new_agent
+        except Exception as e:
+            log_error(f"Failed to create deep copy of {self.__class__.__name__}: {e}")
+            raise
 
     def _deep_copy_field(self, field_name: str, field_value: Any) -> Any:
         """Helper method to deep copy a field based on its type."""
@@ -9898,19 +10527,52 @@ class Agent:
         if field_name == "reasoning_agent":
             return field_value.deep_copy()
 
-        # For storage, model and reasoning_model, use a deep copy
-        elif field_name in ("db", "model", "reasoning_model"):
+        # For tools, share MCP tools but copy others
+        if field_name == "tools" and field_value is not None:
             try:
-                return deepcopy(field_value)
-            except Exception:
-                try:
-                    return copy(field_value)
-                except Exception as e:
-                    log_warning(f"Failed to copy field: {field_name} - {e}")
-                    return field_value
+                copied_tools = []
+                for tool in field_value:
+                    try:
+                        # Share MCP tools (they maintain server connections)
+                        is_mcp_tool = hasattr(type(tool), "__mro__") and any(
+                            c.__name__ in ["MCPTools", "MultiMCPTools"] for c in type(tool).__mro__
+                        )
+                        if is_mcp_tool:
+                            copied_tools.append(tool)
+                        else:
+                            try:
+                                copied_tools.append(deepcopy(tool))
+                            except Exception:
+                                # Tool can't be deep copied, share by reference
+                                copied_tools.append(tool)
+                    except Exception:
+                        # MCP detection failed, share tool by reference to be safe
+                        copied_tools.append(tool)
+                return copied_tools
+            except Exception as e:
+                # If entire tools processing fails, log and return original list
+                log_warning(f"Failed to process tools for deep copy: {e}")
+                return field_value
+
+        # Share heavy resources - these maintain connections/pools that shouldn't be duplicated
+        if field_name in (
+            "db",
+            "model",
+            "reasoning_model",
+            "knowledge",
+            "memory_manager",
+            "parser_model",
+            "output_model",
+            "session_summary_manager",
+            "culture_manager",
+            "compression_manager",
+            "learning",
+            "skills",
+        ):
+            return field_value
 
         # For compound types, attempt a deep copy
-        elif isinstance(field_value, (list, dict, set)):
+        if isinstance(field_value, (list, dict, set)):
             try:
                 return deepcopy(field_value)
             except Exception:
@@ -9921,7 +10583,7 @@ class Agent:
                     return field_value
 
         # For pydantic models, attempt a model_copy
-        elif isinstance(field_value, BaseModel):
+        if isinstance(field_value, BaseModel):
             try:
                 return field_value.model_copy(deep=True)
             except Exception:
@@ -9933,8 +10595,6 @@ class Agent:
 
         # For other types, attempt a shallow copy first
         try:
-            from copy import copy
-
             return copy(field_value)
         except Exception:
             # If copy fails, return as is
@@ -9997,40 +10657,56 @@ class Agent:
     # Reasoning
     ###########################################################################
 
-    def _handle_reasoning(self, run_response: RunOutput, run_messages: RunMessages) -> None:
+    def _handle_reasoning(
+        self, run_response: RunOutput, run_messages: RunMessages, run_context: Optional[RunContext] = None
+    ) -> None:
         if self.reasoning or self.reasoning_model is not None:
             reasoning_generator = self._reason(
-                run_response=run_response, run_messages=run_messages, stream_events=False
+                run_response=run_response, run_messages=run_messages, run_context=run_context, stream_events=False
             )
 
             # Consume the generator without yielding
             deque(reasoning_generator, maxlen=0)
 
     def _handle_reasoning_stream(
-        self, run_response: RunOutput, run_messages: RunMessages, stream_events: Optional[bool] = None
+        self,
+        run_response: RunOutput,
+        run_messages: RunMessages,
+        run_context: Optional[RunContext] = None,
+        stream_events: Optional[bool] = None,
     ) -> Iterator[RunOutputEvent]:
         if self.reasoning or self.reasoning_model is not None:
             reasoning_generator = self._reason(
                 run_response=run_response,
                 run_messages=run_messages,
+                run_context=run_context,
                 stream_events=stream_events,
             )
             yield from reasoning_generator
 
-    async def _ahandle_reasoning(self, run_response: RunOutput, run_messages: RunMessages) -> None:
+    async def _ahandle_reasoning(
+        self, run_response: RunOutput, run_messages: RunMessages, run_context: Optional[RunContext] = None
+    ) -> None:
         if self.reasoning or self.reasoning_model is not None:
-            reason_generator = self._areason(run_response=run_response, run_messages=run_messages, stream_events=False)
+            reason_generator = self._areason(
+                run_response=run_response, run_messages=run_messages, run_context=run_context, stream_events=False
+            )
             # Consume the generator without yielding
             async for _ in reason_generator:  # type: ignore
                 pass
 
     async def _ahandle_reasoning_stream(
-        self, run_response: RunOutput, run_messages: RunMessages, stream_events: Optional[bool] = None
+        self,
+        run_response: RunOutput,
+        run_messages: RunMessages,
+        run_context: Optional[RunContext] = None,
+        stream_events: Optional[bool] = None,
     ) -> AsyncIterator[RunOutputEvent]:
         if self.reasoning or self.reasoning_model is not None:
             reason_generator = self._areason(
                 run_response=run_response,
                 run_messages=run_messages,
+                run_context=run_context,
                 stream_events=stream_events,
             )
             async for item in reason_generator:  # type: ignore
@@ -10142,7 +10818,11 @@ class Agent:
             log_warning(f"Reasoning error. {event.error}, continuing regular session...")
 
     def _reason(
-        self, run_response: RunOutput, run_messages: RunMessages, stream_events: Optional[bool] = None
+        self,
+        run_response: RunOutput,
+        run_messages: RunMessages,
+        run_context: Optional[RunContext] = None,
+        stream_events: Optional[bool] = None,
     ) -> Iterator[RunOutputEvent]:
         """
         Run reasoning using the ReasoningManager.
@@ -10172,9 +10852,7 @@ class Agent:
                 telemetry=self.telemetry,
                 debug_mode=self.debug_mode,
                 debug_level=self.debug_level,
-                session_state=self.session_state,
-                dependencies=self.dependencies,
-                metadata=self.metadata,
+                run_context=run_context,
             )
         )
 
@@ -10183,7 +10861,11 @@ class Agent:
             yield from self._handle_reasoning_event(event, run_response, stream_events)
 
     async def _areason(
-        self, run_response: RunOutput, run_messages: RunMessages, stream_events: Optional[bool] = None
+        self,
+        run_response: RunOutput,
+        run_messages: RunMessages,
+        run_context: Optional[RunContext] = None,
+        stream_events: Optional[bool] = None,
     ) -> Any:
         """
         Run reasoning asynchronously using the ReasoningManager.
@@ -10213,9 +10895,7 @@ class Agent:
                 telemetry=self.telemetry,
                 debug_mode=self.debug_mode,
                 debug_level=self.debug_level,
-                session_state=self.session_state,
-                dependencies=self.dependencies,
-                metadata=self.metadata,
+                run_context=run_context,
             )
         )
 
@@ -10620,6 +11300,118 @@ class Agent:
             name="create_or_update_cultural_knowledge",
         )
 
+    def _create_knowledge_retriever_search_tool(
+        self,
+        run_response: Optional[RunOutput] = None,
+        run_context: Optional[RunContext] = None,
+        async_mode: bool = False,
+    ) -> Function:
+        """Create a search_knowledge_base tool using the custom knowledge_retriever.
+
+        This allows agents to use a custom retriever function without needing
+        a full Knowledge instance. The retriever is wrapped as a tool the agent can call.
+        """
+        from agno.models.message import MessageReferences
+        from agno.utils.timer import Timer
+
+        def search_knowledge_base(query: str) -> str:
+            """Use this function to search the knowledge base for information about a query.
+
+            Args:
+                query: The query to search for.
+
+            Returns:
+                str: A string containing the response from the knowledge base.
+            """
+            retrieval_timer = Timer()
+            retrieval_timer.start()
+
+            try:
+                docs = self.get_relevant_docs_from_knowledge(
+                    query=query,
+                    run_context=run_context,
+                )
+            except Exception as e:
+                log_warning(f"Knowledge retriever failed: {e}")
+                return f"Error searching knowledge base: {e}"
+
+            if run_response is not None and docs:
+                references = MessageReferences(
+                    query=query,
+                    references=docs,
+                    time=round(retrieval_timer.elapsed, 4),
+                )
+                if run_response.references is None:
+                    run_response.references = []
+                run_response.references.append(references)
+
+            retrieval_timer.stop()
+            log_debug(f"Time to get references: {retrieval_timer.elapsed:.4f}s")
+
+            if not docs:
+                return "No documents found"
+
+            # Format results for the agent
+            if self.references_format == "json":
+                import json
+
+                return json.dumps(docs, indent=2, default=str)
+            else:
+                import yaml
+
+                return yaml.dump(docs, default_flow_style=False)
+
+        async def asearch_knowledge_base(query: str) -> str:
+            """Use this function to search the knowledge base for information about a query.
+
+            Args:
+                query: The query to search for.
+
+            Returns:
+                str: A string containing the response from the knowledge base.
+            """
+            retrieval_timer = Timer()
+            retrieval_timer.start()
+
+            try:
+                docs = await self.aget_relevant_docs_from_knowledge(
+                    query=query,
+                    run_context=run_context,
+                )
+            except Exception as e:
+                log_warning(f"Knowledge retriever failed: {e}")
+                return f"Error searching knowledge base: {e}"
+
+            if run_response is not None and docs:
+                references = MessageReferences(
+                    query=query,
+                    references=docs,
+                    time=round(retrieval_timer.elapsed, 4),
+                )
+                if run_response.references is None:
+                    run_response.references = []
+                run_response.references.append(references)
+
+            retrieval_timer.stop()
+            log_debug(f"Time to get references: {retrieval_timer.elapsed:.4f}s")
+
+            if not docs:
+                return "No documents found"
+
+            # Format results for the agent
+            if self.references_format == "json":
+                import json
+
+                return json.dumps(docs, indent=2, default=str)
+            else:
+                import yaml
+
+                return yaml.dump(docs, default_flow_style=False)
+
+        if async_mode:
+            return Function.from_callable(asearch_knowledge_base, name="search_knowledge_base")
+        return Function.from_callable(search_knowledge_base, name="search_knowledge_base")
+
     def _get_chat_history_function(self, session: AgentSession) -> Callable:
         def get_chat_history(num_chats: Optional[int] = None) -> str:
             """Use this function to get the chat history between the user and agent.
@@ -10879,12 +11671,18 @@ class Agent:
 
         if self.knowledge is None:
             return "Knowledge not available"
+
+        # Check if knowledge supports insert
+        insert_fn = getattr(self.knowledge, "insert", None)
+        if not callable(insert_fn):
+            return "Knowledge does not support insert"
+
         document_name = query.replace(" ", "_").replace("?", "").replace("!", "").replace(".", "")
         document_content = json.dumps({"query": query, "result": result})
         log_info(f"Adding document to Knowledge: {document_name}: {document_content}")
         from agno.knowledge.reader.text_reader import TextReader
 
-        self.knowledge.add_content(name=document_name, text_content=document_content, reader=TextReader())
+        insert_fn(name=document_name, text_content=document_content, reader=TextReader())
         return "Successfully added to knowledge base"
 
     def _get_previous_sessions_messages_function(
@@ -11573,7 +12371,7 @@ class Agent:
             "parser_model": self.parser_model.to_dict() if self.parser_model else None,
             "output_model": self.output_model.to_dict() if self.output_model else None,
             "has_tools": self.tools is not None,
-            "has_memory": self.enable_user_memories is True
+            "has_memory": self.update_memory_on_run is True
             or self.enable_agentic_memory is True
             or self.memory_manager is not None,
             "has_learnings": self._learning is not None,
@@ -11627,3 +12425,75 @@ class Agent:
 
         except Exception as e:
             log_debug(f"Could not create Agent run telemetry event: {e}")
+
+
+def get_agent_by_id(
+    db: "BaseDb",
+    id: str,
+    version: Optional[int] = None,
+    label: Optional[str] = None,
+    registry: Optional["Registry"] = None,
+) -> Optional["Agent"]:
+    """
+    Get an Agent by id from the database (new entities/configs schema).
+
+    Resolution order:
+    - if label is provided: load that labeled version
+    - else: load component.current_version
+
+    Args:
+        db: Database handle.
+        id: Agent entity_id.
+        label: Optional label.
+        registry: Optional Registry for reconstructing unserializable components.
+
+    Returns:
+        Agent instance or None.
+    """
+    try:
+        row = db.get_config(component_id=id, label=label, version=version)
+        if row is None:
+            return None
+
+        cfg = row.get("config") if isinstance(row, dict) else None
+        if cfg is None:
+            raise ValueError(f"Invalid config found for agent {id}")
+
+        agent = Agent.from_dict(cfg, registry=registry)
+        agent.id = id
+
+        return agent
+
+    except Exception as e:
+        log_error(f"Error loading Agent {id} from database: {e}")
+        return None
+
+
+def get_agents(
+    db: "BaseDb",
+    registry: Optional["Registry"] = None,
+) -> List["Agent"]:
+    """
+    Get all agents from the database.
+    """
+    agents: List[Agent] = []
+    try:
+        components, _ = db.list_components(component_type=ComponentType.AGENT)
+        for component in components:
+            config = db.get_config(component_id=component["component_id"])
+            if config is not None:
+                agent_config = config.get("config")
+                if agent_config is not None:
+                    component_id = component["component_id"]
+                    if "id" not in agent_config:
+                        agent_config["id"] = component_id
+                    agent = Agent.from_dict(agent_config, registry=registry)
+                    # Ensure agent.id is set to the component_id (the id used to load the agent)
+                    # This ensures events use the correct agent_id
+                    agent.id = component_id
+                    agents.append(agent)
+        return agents
+
+    except Exception as e:
+        log_error(f"Error loading Agents from database: {e}")
+        return []