agno 2.1.9__py3-none-any.whl → 2.1.10__py3-none-any.whl

agno/agent/agent.py

@@ -27,7 +27,9 @@ from uuid import uuid4
 
 from pydantic import BaseModel
 
+from agno.culture.manager import CultureManager
 from agno.db.base import AsyncBaseDb, BaseDb, SessionType, UserMemory
+from agno.db.schemas.culture import CulturalKnowledge
 from agno.exceptions import (
     InputCheckError,
     ModelProviderError,
@@ -349,6 +351,17 @@ class Agent:
     # Metadata stored with this agent
     metadata: Optional[Dict[str, Any]] = None
 
+    # --- Experimental Features ---
+    # --- Agent Culture ---
+    # Culture manager to use for this agent
+    culture_manager: Optional[CultureManager] = None
+    # Enable the agent to manage cultural knowledge
+    enable_agentic_culture: bool = False
+    # Update cultural knowledge after every run
+    update_cultural_knowledge: bool = False
+    # If True, the agent adds cultural knowledge in the response
+    add_culture_to_context: Optional[bool] = None
+
     # --- Debug ---
     # Enable debug logs
     debug_mode: bool = False
@@ -447,6 +460,10 @@ class Agent:
         store_events: bool = False,
         events_to_skip: Optional[List[RunEvent]] = None,
         role: Optional[str] = None,
+        culture_manager: Optional[CultureManager] = None,
+        enable_agentic_culture: bool = False,
+        update_cultural_knowledge: bool = False,
+        add_culture_to_context: Optional[bool] = None,
         debug_mode: bool = False,
         debug_level: Literal[1, 2] = 1,
         telemetry: bool = True,
@@ -566,6 +583,11 @@ class Agent:
         if self.events_to_skip is None:
             self.events_to_skip = [RunEvent.run_content]
 
+        self.culture_manager = culture_manager
+        self.enable_agentic_culture = enable_agentic_culture
+        self.update_cultural_knowledge = update_cultural_knowledge
+        self.add_culture_to_context = add_culture_to_context
+
         self.debug_mode = debug_mode
         if debug_level not in [1, 2]:
             log_warning(f"Invalid debug level: {debug_level}. Setting to 1.")
@@ -669,6 +691,23 @@ class Agent:
                 f"Cannot validate {type(input)} against input_schema. Expected dict or {self.input_schema.__name__} instance."
             )
 
+    def _set_culture_manager(self) -> None:
+        if self.db is None:
+            log_warning("Database not provided. Cultural knowledge will not be stored.")
+
+        if self.culture_manager is None:
+            self.culture_manager = CultureManager(model=self.model, db=self.db)
+        else:
+            if self.culture_manager.model is None:
+                self.culture_manager.model = self.model
+            if self.culture_manager.db is None:
+                self.culture_manager.db = self.db
+
+        if self.add_culture_to_context is None:
+            self.add_culture_to_context = (
+                self.enable_agentic_culture or self.update_cultural_knowledge or self.culture_manager is not None
+            )
+
     def _set_memory_manager(self) -> None:
         if self.db is None:
             log_warning("Database not provided. Memories will not be stored.")
@@ -709,6 +748,13 @@ class Agent:
         self.set_id()
         if self.enable_user_memories or self.enable_agentic_memory or self.memory_manager is not None:
             self._set_memory_manager()
+        if (
+            self.add_culture_to_context
+            or self.update_cultural_knowledge
+            or self.enable_agentic_culture
+            or self.culture_manager is not None
+        ):
+            self._set_culture_manager()
         if self.enable_session_summaries or self.session_summary_manager is not None:
             self._set_session_summary_manager()
 
@@ -791,8 +837,8 @@ class Agent:
         debug_mode: Optional[bool] = None,
         **kwargs: Any,
     ) -> RunOutput:
-        """
-        Run the Agent and return the RunOutput.
+        """Run the Agent and return the RunOutput.
+
         Steps:
         1. Execute pre-hooks
         2. Prepare run messages
@@ -803,7 +849,7 @@ class Agent:
         7. Calculate session metrics
         8. Optional: Save output to file if save_response_to_file is set
         9. Add RunOutput to Agent Session
-        10. Update Agent Memory
+        10. Update Agent Memory, Cultural Knowledge and Summaries
         11. Save session to storage
         """
 
@@ -865,7 +911,7 @@ class Agent:
 
         log_debug(f"Agent Run Start: {run_response.run_id}", center=True)
 
-        # 3. Reason about the task
+        # 3. Reason about the task if reasoning is enabled
         self._handle_reasoning(run_response=run_response, run_messages=run_messages)
 
         # Check for cancellation before model call
@@ -894,7 +940,11 @@ class Agent:
         self._parse_response_with_parser_model(model_response, run_messages)
 
         # 5. Update the RunOutput with the model response
-        self._update_run_response(model_response=model_response, run_response=run_response, run_messages=run_messages)
+        self._update_run_response(
+            model_response=model_response,
+            run_response=run_response,
+            run_messages=run_messages,
+        )
 
         if self.store_media:
             self._store_media(run_response, model_response)
@@ -902,7 +952,10 @@ class Agent:
         # We should break out of the run function
         if any(tool_call.is_paused for tool_call in run_response.tools or []):
             return self._handle_agent_run_paused(
-                run_response=run_response, run_messages=run_messages, session=session, user_id=user_id
+                run_response=run_response,
+                run_messages=run_messages,
+                session=session,
+                user_id=user_id,
             )
 
         # Convert the response to the structured format if needed
@@ -931,15 +984,21 @@ class Agent:
 
         # 8. Optional: Save output to file if save_response_to_file is set
         self.save_run_response_to_file(
-            run_response=run_response, input=run_messages.user_message, session_id=session.session_id, user_id=user_id
+            run_response=run_response,
+            input=run_messages.user_message,
+            session_id=session.session_id,
+            user_id=user_id,
         )
 
         # 9. Add the RunOutput to Agent Session
         session.upsert_run(run=run_response)
 
-        # 10. Update Agent Memory
-        response_iterator = self._make_memories_and_summaries(
-            run_response=run_response, run_messages=run_messages, session=session, user_id=user_id
+        # 10. Update Agent Memory, Cultural Knowledge and Summaries
+        response_iterator = self._make_memories_cultural_knowledge_and_summaries(
+            run_response=run_response,
+            run_messages=run_messages,
+            session=session,
+            user_id=user_id,
         )
         # Consume the response iterator to ensure the memory is updated before the run is completed
         deque(response_iterator, maxlen=0)
@@ -989,7 +1048,7 @@ class Agent:
         5. Calculate session metrics
         6. Optional: Save output to file if save_response_to_file is set
         7. Add the RunOutput to the Agent Session
-        8. Update Agent Memory
+        8. Update Agent Memory, Cultural Knowledge and Summaries
         9. Create the run completed event
         10. Save session to storage
         """
@@ -1063,7 +1122,7 @@ class Agent:
             # Check for cancellation before model processing
             raise_if_cancelled(run_response.run_id)  # type: ignore
 
-            # 4. Process model response
+            # 4. Generate a response from the Model (includes running function calls)
             if self.output_model is None:
                 for event in self._handle_model_response_stream(
                     session=session,
@@ -1112,13 +1171,18 @@ class Agent:
 
             # If a parser model is provided, structure the response separately
             yield from self._parse_response_with_parser_model_stream(
-                session=session, run_response=run_response, stream_intermediate_steps=stream_intermediate_steps
+                session=session,
+                run_response=run_response,
+                stream_intermediate_steps=stream_intermediate_steps,
             )
 
             # We should break out of the run function
             if any(tool_call.is_paused for tool_call in run_response.tools or []):
                 yield from self._handle_agent_run_paused_stream(
-                    run_response=run_response, run_messages=run_messages, session=session, user_id=user_id
+                    run_response=run_response,
+                    run_messages=run_messages,
+                    session=session,
+                    user_id=user_id,
                 )
                 return
 
@@ -1156,9 +1220,12 @@ class Agent:
             # 7. Add RunOutput to Agent Session
             session.upsert_run(run=run_response)
 
-            # 8. Update Agent Memory
-            yield from self._make_memories_and_summaries(
-                run_response=run_response, run_messages=run_messages, session=session, user_id=user_id
+            # 8. Update Agent Memory, Cultural Knowledge and Summaries
+            yield from self._make_memories_cultural_knowledge_and_summaries(
+                run_response=run_response,
+                run_messages=run_messages,
+                session=session,
+                user_id=user_id,
             )
 
             # 9. Create the run completed event
@@ -1299,7 +1366,10 @@ class Agent:
             self._hooks_normalised = True
 
         session_id, user_id, session_state = self._initialize_session(
-            run_id=run_id, session_id=session_id, user_id=user_id, session_state=session_state
+            run_id=run_id,
+            session_id=session_id,
+            user_id=user_id,
+            session_state=session_state,
         )
 
         # Initialize the Agent
@@ -1470,7 +1540,10 @@ class Agent:
 
                 if stream:
                     return generator_wrapper(  # type: ignore
-                        create_run_cancelled_event(from_run_response=run_response, reason="Operation cancelled by user")
+                        create_run_cancelled_event(
+                            from_run_response=run_response,
+                            reason="Operation cancelled by user",
+                        )
                     )
                 else:
                     return run_response
@@ -1623,7 +1696,9 @@ class Agent:
 
             # 9. Update the RunOutput with the model response
             self._update_run_response(
-                model_response=model_response, run_response=run_response, run_messages=run_messages
+                model_response=model_response,
+                run_response=run_response,
+                run_messages=run_messages,
             )
 
             # Optional: Store media
@@ -1633,7 +1708,10 @@ class Agent:
             # Break out of the run function if a tool call is paused
             if any(tool_call.is_paused for tool_call in run_response.tools or []):
                 return self._handle_agent_run_paused(
-                    run_response=run_response, run_messages=run_messages, session=agent_session, user_id=user_id
+                    run_response=run_response,
+                    run_messages=run_messages,
+                    session=agent_session,
+                    user_id=user_id,
                 )
             raise_if_cancelled(run_response.run_id)  # type: ignore
 
@@ -1675,9 +1753,12 @@ class Agent:
             # 11. Add RunOutput to Agent Session
             agent_session.upsert_run(run=run_response)
 
-            # 12. Update Agent Memory
-            async for _ in self._amake_memories_and_summaries(
-                run_response=run_response, run_messages=run_messages, session=agent_session, user_id=user_id
+            # 12. Update Agent Memory, Cultural Knowledge and Summaries
+            async for _ in self._amake_memories_cultural_knowledge_and_summaries(
+                run_response=run_response,
+                run_messages=run_messages,
+                session=agent_session,
+                user_id=user_id,
             ):
                 pass
 
@@ -1884,14 +1965,19 @@ class Agent:
 
             # If a parser model is provided, structure the response separately
             async for event in self._aparse_response_with_parser_model_stream(
-                session=agent_session, run_response=run_response, stream_intermediate_steps=stream_intermediate_steps
+                session=agent_session,
+                run_response=run_response,
+                stream_intermediate_steps=stream_intermediate_steps,
             ):
                 yield event
 
             # Break out of the run function if a tool call is paused
             if any(tool_call.is_paused for tool_call in run_response.tools or []):
                 for item in self._handle_agent_run_paused_stream(
-                    run_response=run_response, run_messages=run_messages, session=agent_session, user_id=user_id
+                    run_response=run_response,
+                    run_messages=run_messages,
+                    session=agent_session,
+                    user_id=user_id,
                 ):
                     yield item
                 return
@@ -1932,8 +2018,11 @@ class Agent:
             agent_session.upsert_run(run=run_response)
 
             # 11. Update Agent Memory
-            async for event in self._amake_memories_and_summaries(
-                run_response=run_response, run_messages=run_messages, session=agent_session, user_id=user_id
+            async for event in self._amake_memories_cultural_knowledge_and_summaries(
+                run_response=run_response,
+                run_messages=run_messages,
+                session=agent_session,
+                user_id=user_id,
             ):
                 yield event
 
@@ -2077,7 +2166,10 @@ class Agent:
 
         # Initialize session
         session_id, user_id, session_state = self._initialize_session(
-            run_id=run_id, session_id=session_id, user_id=user_id, session_state=session_state
+            run_id=run_id,
+            session_id=session_id,
+            user_id=user_id,
+            session_state=session_state,
         )
 
         # Initialize the Agent
@@ -2224,7 +2316,10 @@ class Agent:
 
                 if stream:
                     return async_generator_wrapper(  # type: ignore
-                        create_run_cancelled_event(from_run_response=run_response, reason="Operation cancelled by user")
+                        create_run_cancelled_event(
+                            from_run_response=run_response,
+                            reason="Operation cancelled by user",
+                        )
                     )
                 else:
                     return run_response
@@ -2531,12 +2626,19 @@ class Agent:
             tool_call_limit=self.tool_call_limit,
         )
 
-        self._update_run_response(model_response=model_response, run_response=run_response, run_messages=run_messages)
+        self._update_run_response(
+            model_response=model_response,
+            run_response=run_response,
+            run_messages=run_messages,
+        )
 
         # We should break out of the run function
         if any(tool_call.is_paused for tool_call in run_response.tools or []):
             return self._handle_agent_run_paused(
-                run_response=run_response, run_messages=run_messages, session=session, user_id=user_id
+                run_response=run_response,
+                run_messages=run_messages,
+                session=session,
+                user_id=user_id,
             )
 
         # 3. Calculate session metrics
@@ -2565,15 +2667,21 @@ class Agent:
 
         # 4. Save output to file if save_response_to_file is set
         self.save_run_response_to_file(
-            run_response=run_response, input=run_messages.user_message, session_id=session.session_id, user_id=user_id
+            run_response=run_response,
+            input=run_messages.user_message,
+            session_id=session.session_id,
+            user_id=user_id,
         )
 
         # 5. Add the run to memory
         session.upsert_run(run=run_response)
 
-        # 6. Update Agent Memory
-        response_iterator = self._make_memories_and_summaries(
-            run_response=run_response, run_messages=run_messages, session=session, user_id=user_id
+        # 6. Update Agent Memory, Cultural Knowledge and Summaries
+        response_iterator = self._make_memories_cultural_knowledge_and_summaries(
+            run_response=run_response,
+            run_messages=run_messages,
+            session=session,
+            user_id=user_id,
         )
         # Consume the response iterator to ensure the memory is updated before the run is completed
         deque(response_iterator, maxlen=0)
@@ -2636,7 +2744,10 @@ class Agent:
         # We should break out of the run function
         if any(tool_call.is_paused for tool_call in run_response.tools or []):
             yield from self._handle_agent_run_paused_stream(
-                run_response=run_response, run_messages=run_messages, session=session, user_id=user_id
+                run_response=run_response,
+                run_messages=run_messages,
+                session=session,
+                user_id=user_id,
             )
             return
 
@@ -2664,15 +2775,21 @@ class Agent:
 
         # 4. Save output to file if save_response_to_file is set
         self.save_run_response_to_file(
-            run_response=run_response, input=run_messages.user_message, session_id=session.session_id, user_id=user_id
+            run_response=run_response,
+            input=run_messages.user_message,
+            session_id=session.session_id,
+            user_id=user_id,
         )
 
         # 5. Add the run to memory
         session.upsert_run(run=run_response)
 
         # 6. Update Agent Memory
-        yield from self._make_memories_and_summaries(
-            run_response=run_response, run_messages=run_messages, session=session, user_id=user_id
+        yield from self._make_memories_cultural_knowledge_and_summaries(
+            run_response=run_response,
+            run_messages=run_messages,
+            session=session,
+            user_id=user_id,
         )
 
         # 7. Create the run completed event
@@ -2998,7 +3115,9 @@ class Agent:
 
             # 9. Update the RunOutput with the model response
             self._update_run_response(
-                model_response=model_response, run_response=run_response, run_messages=run_messages
+                model_response=model_response,
+                run_response=run_response,
+                run_messages=run_messages,
             )
 
             if self.store_media:
@@ -3009,7 +3128,10 @@ class Agent:
             # Break out of the run function if a tool call is paused
             if any(tool_call.is_paused for tool_call in run_response.tools or []):
                 return self._handle_agent_run_paused(
-                    run_response=run_response, run_messages=run_messages, session=agent_session, user_id=user_id
+                    run_response=run_response,
+                    run_messages=run_messages,
+                    session=agent_session,
+                    user_id=user_id,
                 )
             raise_if_cancelled(run_response.run_id)  # type: ignore
 
@@ -3039,8 +3161,11 @@ class Agent:
                 run_response.metrics.stop_timer()
 
             # 12. Update Agent Memory
-            async for _ in self._amake_memories_and_summaries(
-                run_response=run_response, run_messages=run_messages, session=agent_session, user_id=user_id
+            async for _ in self._amake_memories_cultural_knowledge_and_summaries(
+                run_response=run_response,
+                run_messages=run_messages,
+                session=agent_session,
+                user_id=user_id,
             ):
                 pass
 
@@ -3238,7 +3363,10 @@ class Agent:
             # Break out of the run function if a tool call is paused
             if any(tool_call.is_paused for tool_call in run_response.tools or []):
                 for item in self._handle_agent_run_paused_stream(
-                    run_response=run_response, run_messages=run_messages, session=agent_session, user_id=user_id
+                    run_response=run_response,
+                    run_messages=run_messages,
+                    session=agent_session,
+                    user_id=user_id,
                 ):
                     yield item
                 return
@@ -3281,8 +3409,11 @@ class Agent:
             self._update_session_metrics(session=agent_session, run_response=run_response)
 
             # 12. Update Agent Memory
-            async for event in self._amake_memories_and_summaries(
-                run_response=run_response, run_messages=run_messages, session=agent_session, user_id=user_id
+            async for event in self._amake_memories_cultural_knowledge_and_summaries(
+                run_response=run_response,
+                run_messages=run_messages,
+                session=agent_session,
+                user_id=user_id,
             ):
                 yield event
 
@@ -3358,7 +3489,9 @@ class Agent:
             yield self._handle_event(
                 run_response=run_response,
                 event=create_pre_hook_started_event(
-                    from_run_response=run_response, run_input=run_input, pre_hook_name=hook.__name__
+                    from_run_response=run_response,
+                    run_input=run_input,
+                    pre_hook_name=hook.__name__,
                 ),
             )
             try:
@@ -3370,7 +3503,9 @@ class Agent:
                 yield self._handle_event(
                     run_response=run_response,
                     event=create_pre_hook_completed_event(
-                        from_run_response=run_response, run_input=run_input, pre_hook_name=hook.__name__
+                        from_run_response=run_response,
+                        run_input=run_input,
+                        pre_hook_name=hook.__name__,
                     ),
                 )
 
@@ -3420,7 +3555,9 @@ class Agent:
             yield self._handle_event(
                 run_response=run_response,
                 event=create_pre_hook_started_event(
-                    from_run_response=run_response, run_input=run_input, pre_hook_name=hook.__name__
+                    from_run_response=run_response,
+                    run_input=run_input,
+                    pre_hook_name=hook.__name__,
                 ),
             )
             try:
@@ -3436,7 +3573,9 @@ class Agent:
                 yield self._handle_event(
                     run_response=run_response,
                     event=create_pre_hook_completed_event(
-                        from_run_response=run_response, run_input=run_input, pre_hook_name=hook.__name__
+                        from_run_response=run_response,
+                        run_input=run_input,
+                        pre_hook_name=hook.__name__,
                     ),
                 )
 
@@ -3559,7 +3698,10 @@ class Agent:
 
         # Save output to file if save_response_to_file is set
         self.save_run_response_to_file(
-            run_response=run_response, input=run_messages.user_message, session_id=session.session_id, user_id=user_id
+            run_response=run_response,
+            input=run_messages.user_message,
+            session_id=session.session_id,
+            user_id=user_id,
         )
 
         session.upsert_run(run=run_response)
@@ -3596,7 +3738,10 @@ class Agent:
 
         # Save output to file if save_response_to_file is set
         self.save_run_response_to_file(
-            run_response=run_response, input=run_messages.user_message, session_id=session.session_id, user_id=user_id
+            run_response=run_response,
+            input=run_messages.user_message,
+            session_id=session.session_id,
+            user_id=user_id,
         )
         session.upsert_run(run=run_response)
         # Save session to storage
@@ -3703,7 +3848,9 @@ class Agent:
                     tool.tool_call_error = tool_execution.tool_call_error
                     yield self._handle_event(
                         create_tool_call_completed_event(
-                            from_run_response=run_response, tool=tool, content=call_result.content
+                            from_run_response=run_response,
+                            tool=tool,
+                            content=call_result.content,
                         ),
                         run_response,
                     )
@@ -3750,7 +3897,9 @@ class Agent:
                     tool.tool_call_error = tool_execution.tool_call_error
                     yield self._handle_event(
                         create_tool_call_completed_event(
-                            from_run_response=run_response, tool=tool, content=call_result.content
+                            from_run_response=run_response,
+                            tool=tool,
+                            content=call_result.content,
                         ),
                         run_response,
                     )
@@ -3925,7 +4074,12 @@ class Agent:
             for file in model_response.files:
                 self._add_file(file, run_response)  # Generated files go to run_response.files
 
-    def _update_run_response(self, model_response: ModelResponse, run_response: RunOutput, run_messages: RunMessages):
+    def _update_run_response(
+        self,
+        model_response: ModelResponse,
+        run_response: RunOutput,
+        run_messages: RunMessages,
+    ):
         # Handle structured outputs
         if self.output_schema is not None and model_response.parsed is not None:
             # We get native structured outputs from the model
@@ -3966,7 +4120,9 @@ class Agent:
                 if tool_name.lower() in ["think", "analyze"]:
                     tool_args = tool_call.tool_args or {}
                     self._update_reasoning_content_from_tool_call(
-                        run_response=run_response, tool_name=tool_name, tool_args=tool_args
+                        run_response=run_response,
+                        tool_name=tool_name,
+                        tool_args=tool_args,
                     )
 
         # Update the run_response audio with the model response audio
@@ -4045,7 +4201,8 @@ class Agent:
 
             if all_reasoning_steps:
                 add_reasoning_metrics_to_metadata(
-                    run_response=run_response, reasoning_time_taken=reasoning_state["reasoning_time_taken"]
+                    run_response=run_response,
+                    reasoning_time_taken=reasoning_state["reasoning_time_taken"],
                 )
                 yield self._handle_event(
                     create_reasoning_completed_event(
@@ -4122,7 +4279,8 @@ class Agent:
 
             if all_reasoning_steps:
                 add_reasoning_metrics_to_metadata(
-                    run_response=run_response, reasoning_time_taken=reasoning_state["reasoning_time_taken"]
+                    run_response=run_response,
+                    reasoning_time_taken=reasoning_state["reasoning_time_taken"],
                 )
                 yield self._handle_event(
                     create_reasoning_completed_event(
@@ -4342,14 +4500,16 @@ class Agent:
                     # Yield each tool call started event
                     for tool in tool_executions_list:
                         yield self._handle_event(
-                            create_tool_call_started_event(from_run_response=run_response, tool=tool), run_response
+                            create_tool_call_started_event(from_run_response=run_response, tool=tool),
+                            run_response,
                         )
 
             # If the model response is a tool_call_completed, update the existing tool call in the run_response
             elif model_response_event.event == ModelResponseEvent.tool_call_completed.value:
                 if model_response_event.updated_session_state is not None and session.session_data is not None:
                     merge_dictionaries(
-                        session.session_data["session_state"], model_response_event.updated_session_state
+                        session.session_data["session_state"],
+                        model_response_event.updated_session_state,
                     )
 
                 if model_response_event.images is not None:
@@ -4390,7 +4550,9 @@ class Agent:
                             tool_args = tool_call.tool_args or {}
 
                             reasoning_step = self._update_reasoning_content_from_tool_call(
-                                run_response=run_response, tool_name=tool_name, tool_args=tool_args
+                                run_response=run_response,
+                                tool_name=tool_name,
+                                tool_args=tool_args,
                             )
 
                             tool_call_metrics = tool_call.metrics
@@ -4406,7 +4568,9 @@ class Agent:
 
                         yield self._handle_event(
                             create_tool_call_completed_event(
-                                from_run_response=run_response, tool=tool_call, content=model_response_event.content
+                                from_run_response=run_response,
+                                tool=tool_call,
+                                content=model_response_event.content,
                             ),
                             run_response,
                         )
@@ -4415,7 +4579,8 @@ class Agent:
                     if reasoning_step is not None:
                         if reasoning_state and not reasoning_state["reasoning_started"]:
                             yield self._handle_event(
-                                create_reasoning_started_event(from_run_response=run_response), run_response
+                                create_reasoning_started_event(from_run_response=run_response),
+                                run_response,
                             )
                             reasoning_state["reasoning_started"] = True
 
@@ -4428,7 +4593,7 @@ class Agent:
                             run_response,
                         )
 
-    def _make_memories_and_summaries(
+    def _make_memories_cultural_knowledge_and_summaries(
         self,
         run_response: RunOutput,
         run_messages: RunMessages,
@@ -4440,10 +4605,11 @@ class Agent:
         with ThreadPoolExecutor(max_workers=3) as executor:
             futures = []
 
-            # Create user memories
             user_message_str = (
                 run_messages.user_message.get_content_string() if run_messages.user_message is not None else None
             )
+
+            # Create user memories
             if user_message_str is not None and self.memory_manager is not None and not self.enable_agentic_memory:
                 log_debug("Creating user memories.")
                 futures.append(
@@ -4486,6 +4652,16 @@ class Agent:
                 else:
                     log_warning("Unable to add messages to memory")
 
+            # Create cultural knowledge
+            if user_message_str is not None and self.culture_manager is not None and self.update_cultural_knowledge:
+                log_debug("Creating cultural knowledge.")
+                futures.append(
+                    executor.submit(
+                        self.culture_manager.create_cultural_knowledge,
+                        message=user_message_str,
+                    )
+                )
+
             # Create session summary
             if self.session_summary_manager is not None:
                 log_debug("Creating session summary.")
@@ -4499,7 +4675,8 @@ class Agent:
             if futures:
                 if self.stream_intermediate_steps:
                     yield self._handle_event(
-                        create_memory_update_started_event(from_run_response=run_response), run_response
+                        create_memory_update_started_event(from_run_response=run_response),
+                        run_response,
                     )
 
                 # Wait for all operations to complete and handle any errors
@@ -4511,10 +4688,11 @@ class Agent:
 
                 if self.stream_intermediate_steps:
                     yield self._handle_event(
-                        create_memory_update_completed_event(from_run_response=run_response), run_response
+                        create_memory_update_completed_event(from_run_response=run_response),
+                        run_response,
                     )
 
-    async def _amake_memories_and_summaries(
+    async def _amake_memories_cultural_knowledge_and_summaries(
         self,
         run_response: RunOutput,
         run_messages: RunMessages,
@@ -4529,7 +4707,9 @@ class Agent:
 
             tasks.append(
                 self.memory_manager.acreate_user_memories(
-                    message=run_messages.user_message.get_content_string(), user_id=user_id, agent_id=self.id
+                    message=run_messages.user_message.get_content_string(),
+                    user_id=user_id,
+                    agent_id=self.id,
                 )
             )
 
@@ -4561,6 +4741,18 @@ class Agent:
             else:
                 log_warning("Unable to add messages to memory")
 
+        # Create cultural knowledge
+        if (
+            run_messages.user_message is not None
+            and self.culture_manager is not None
+            and self.update_cultural_knowledge
+        ):
+            log_debug("Creating cultural knowledge.")
+
+            tasks.append(
+                self.culture_manager.acreate_cultural_knowledge(message=run_messages.user_message.get_content_string())
+            )
+
         # Create session summary
         if self.session_summary_manager is not None:
             log_debug("Creating session summary.")
@@ -4573,7 +4765,8 @@ class Agent:
         if tasks:
             if self.stream_intermediate_steps:
                 yield self._handle_event(
-                    create_memory_update_started_event(from_run_response=run_response), run_response
+                    create_memory_update_started_event(from_run_response=run_response),
+                    run_response,
                 )
 
             # Execute all tasks concurrently and handle any errors
@@ -4584,7 +4777,8 @@ class Agent:
 
             if self.stream_intermediate_steps:
                 yield self._handle_event(
-                    create_memory_update_completed_event(from_run_response=run_response), run_response
+                    create_memory_update_completed_event(from_run_response=run_response),
+                    run_response,
                 )
 
     def _raise_if_async_tools(self) -> None:
@@ -4634,7 +4828,15 @@ class Agent:
 
             # If any of the tools has "agent" as parameter, set _rebuild_tools to True
             for tool in agent_tools:
-                param_names = {"agent", "session_state", "team", "images", "videos", "audios", "files"}
+                param_names = {
+                    "agent",
+                    "session_state",
+                    "team",
+                    "images",
+                    "videos",
+                    "audios",
+                    "files",
+                }
 
                 if isinstance(tool, Function):
                     if param_names & set(tool.parameters):
@@ -4671,6 +4873,10 @@ class Agent:
             agent_tools.append(self._get_update_user_memory_function(user_id=user_id, async_mode=async_mode))
             self._rebuild_tools = True
 
+        if self.enable_agentic_culture:
+            agent_tools.append(self._get_update_cultural_knowledge_function(async_mode=async_mode))
+            self._rebuild_tools = True
+
         if self.enable_agentic_state:
             agent_tools.append(self.update_session_state)
 
@@ -4690,13 +4896,17 @@ class Agent:
                 if self.enable_agentic_knowledge_filters:
                     agent_tools.append(
                         self._search_knowledge_base_with_agentic_filters_function(
-                            run_response=run_response, async_mode=async_mode, knowledge_filters=knowledge_filters
+                            run_response=run_response,
+                            async_mode=async_mode,
+                            knowledge_filters=knowledge_filters,
                         )
                     )
                 else:
                     agent_tools.append(
                         self._get_search_knowledge_base_function(
-                            run_response=run_response, async_mode=async_mode, knowledge_filters=knowledge_filters
+                            run_response=run_response,
+                            async_mode=async_mode,
+                            knowledge_filters=knowledge_filters,
                         )
                     )
                 self._rebuild_tools = True
@@ -4784,13 +4994,17 @@ class Agent:
                 if self.enable_agentic_knowledge_filters:
                     agent_tools.append(
                         self._search_knowledge_base_with_agentic_filters_function(
-                            run_response=run_response, async_mode=async_mode, knowledge_filters=knowledge_filters
+                            run_response=run_response,
+                            async_mode=async_mode,
+                            knowledge_filters=knowledge_filters,
                         )
                     )
                 else:
                     agent_tools.append(
                         self._get_search_knowledge_base_function(
-                            run_response=run_response, async_mode=async_mode, knowledge_filters=knowledge_filters
+                            run_response=run_response,
+                            async_mode=async_mode,
+                            knowledge_filters=knowledge_filters,
                         )
                     )
                 self._rebuild_tools = True
@@ -5614,7 +5828,10 @@ class Agent:
         self.save_session(session=session)  # type: ignore
 
     def set_session_name(
-        self, session_id: Optional[str] = None, autogenerate: bool = False, session_name: Optional[str] = None
+        self,
+        session_id: Optional[str] = None,
+        autogenerate: bool = False,
+        session_name: Optional[str] = None,
     ) -> AgentSession:
         """Set the session name and save to storage"""
         session_id = session_id or self.session_id
@@ -5775,6 +5992,20 @@ class Agent:
 
         return await self.memory_manager.aget_user_memories(user_id=user_id)
 
+    def get_culture_knowledge(self) -> Optional[List[CulturalKnowledge]]:
+        """Get the cultural knowledge the agent has access to"""
+        if self.culture_manager is None:
+            return None
+
+        return self.culture_manager.get_all_knowledge()
+
+    async def aget_culture_knowledge(self) -> Optional[List[CulturalKnowledge]]:
+        """Get the cultural knowledge the agent has access to"""
+        if self.culture_manager is None:
+            return None
+
+        return await self.culture_manager.aget_all_knowledge()
+
     def _format_message_with_state_variables(
         self,
         message: Any,
@@ -5924,7 +6155,14 @@ class Agent:
             location = get_location()
             if location:
                 location_str = ", ".join(
-                    filter(None, [location.get("city"), location.get("region"), location.get("country")])
+                    filter(
+                        None,
+                        [
+                            location.get("city"),
+                            location.get("region"),
+                            location.get("country"),
+                        ],
+                    )
                 )
                 if location_str:
                     additional_information.append(f"Your approximate location is: {location_str}.")
@@ -5939,7 +6177,8 @@ class Agent:
             if valid_filters:
                 valid_filters_str = ", ".join(valid_filters)
                 additional_information.append(
-                    dedent(f"""
+                    dedent(
+                        f"""
                     The knowledge base contains documents with these metadata filters: {valid_filters_str}.
                     Always use filters when the user query indicates specific metadata.
 
@@ -5955,7 +6194,8 @@ class Agent:
                     - 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.3 Build the default system message for the Agent.
@@ -6043,6 +6283,67 @@ class Agent:
                     "</updating_user_memories>\n\n"
                 )
 
+        # 3.3.10 Then add cultural knowledge to the system prompt
+        if self.add_culture_to_context:
+            _culture_manager_not_set = None
+            if not self.culture_manager:
+                self._set_culture_manager()
+                _culture_manager_not_set = True
+
+            cultural_knowledge = self.culture_manager.get_all_knowledge()  # type: ignore
+
+            if cultural_knowledge and len(cultural_knowledge) > 0:
+                system_message_content += (
+                    "You have access to shared **Cultural Knowledge**, which provides context, norms, rules and guidance "
+                    "for your reasoning, communication, and decision-making. "
+                    "Cultural Knowledge represents the collective understanding, values, rules and practices that have "
+                    "emerged across agents and teams. It encodes collective experience — including preferred "
+                    "approaches, common patterns, lessons learned, and ethical guardrails.\n\n"
+                    "When performing any task:\n"
+                    "- **Reference Cultural Knowledge** to align with shared norms and best practices.\n"
+                    "- **Apply it contextually**, not mechanically — adapt principles to the current situation.\n"
+                    "- **Preserve consistency** with cultural values (tone, reasoning, and style) unless explicitly told otherwise.\n"
+                    "- **Extend it** when you discover new insights — your outputs may become future Cultural Knowledge.\n"
+                    "- **Clarify conflicts** if Cultural Knowledge appears to contradict explicit user instructions.\n\n"
+                    "Your goal is to act not only intelligently but also *culturally coherently* — reflecting the "
+                    "collective intelligence of the system.\n\n"
+                    "Below is the currently available Cultural Knowledge for this context:\n\n"
+                )
+                system_message_content += "<cultural_knowledge>"
+                for _knowledge in cultural_knowledge:  # type: ignore
+                    system_message_content += "\n---"
+                    system_message_content += f"\nName: {_knowledge.name}"
+                    system_message_content += f"\nSummary: {_knowledge.summary}"
+                    system_message_content += f"\nContent: {_knowledge.content}"
+                system_message_content += "\n</cultural_knowledge>\n"
+            else:
+                system_message_content += (
+                    "You have the capability to access shared **Cultural Knowledge**, which normally provides "
+                    "context, norms, and guidance for your behavior and reasoning. However, no cultural knowledge "
+                    "is currently available in this session.\n"
+                    "Proceed thoughtfully and document any useful insights you create — they may become future "
+                    "Cultural Knowledge for others.\n\n"
+                )
+
+            if _culture_manager_not_set:
+                self.culture_manager = None
+
+            if self.enable_agentic_culture:
+                system_message_content += (
+                    "\n<contributing_to_culture>\n"
+                    "When you discover an insight, pattern, rule, or best practice that will help future agents, use the `create_or_update_cultural_knowledge` tool to add or update entries in the shared cultural knowledge.\n"
+                    "\n"
+                    "When to contribute:\n"
+                    "- You discover a reusable insight, pattern, rule, or best practice that will help future agents.\n"
+                    "- You correct or clarify an existing cultural entry.\n"
+                    "- You capture a guardrail, decision rationale, postmortem lesson, or example template.\n"
+                    "- You identify missing context that should persist across sessions or teams.\n"
+                    "\n"
+                    "Cultural knowledge should capture reusable insights, best practices, or contextual knowledge that transcends individual conversations.\n"
+                    "Mention your contribution to the user only if it is relevant to their request or they asked to be notified.\n"
+                    "</contributing_to_culture>\n\n"
+                )
+
         # 3.3.11 Then add a summary of the interaction to the system prompt
         if self.add_session_summary_to_context and session.summary is not None:
             system_message_content += "Here is a brief summary of your previous interactions:\n\n"
@@ -6195,7 +6496,14 @@ class Agent:
             location = get_location()
             if location:
                 location_str = ", ".join(
-                    filter(None, [location.get("city"), location.get("region"), location.get("country")])
+                    filter(
+                        None,
+                        [
+                            location.get("city"),
+                            location.get("region"),
+                            location.get("country"),
+                        ],
+                    )
                 )
                 if location_str:
                     additional_information.append(f"Your approximate location is: {location_str}.")
@@ -6210,7 +6518,8 @@ class Agent:
             if valid_filters:
                 valid_filters_str = ", ".join(valid_filters)
                 additional_information.append(
-                    dedent(f"""
+                    dedent(
+                        f"""
                     The knowledge base contains documents with these metadata filters: {valid_filters_str}.
                     Always use filters when the user query indicates specific metadata.
 
@@ -6226,7 +6535,8 @@ class Agent:
                     - 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.3 Build the default system message for the Agent.
@@ -6317,6 +6627,67 @@ class Agent:
                     "</updating_user_memories>\n\n"
                 )
 
+        # 3.3.10 Then add cultural knowledge to the system prompt
+        if self.add_culture_to_context:
+            _culture_manager_not_set = None
+            if not self.culture_manager:
+                self._set_culture_manager()
+                _culture_manager_not_set = True
+
+            cultural_knowledge = await self.culture_manager.aget_all_knowledge()  # type: ignore
+
+            if cultural_knowledge and len(cultural_knowledge) > 0:
+                system_message_content += (
+                    "You have access to shared **Cultural Knowledge**, which provides context, norms, rules and guidance "
+                    "for your reasoning, communication, and decision-making.\n\n"
+                    "Cultural Knowledge represents the collective understanding, values, rules and practices that have "
+                    "emerged across agents and teams. It encodes collective experience — including preferred "
+                    "approaches, common patterns, lessons learned, and ethical guardrails.\n\n"
+                    "When performing any task:\n"
+                    "- **Reference Cultural Knowledge** to align with shared norms and best practices.\n"
+                    "- **Apply it contextually**, not mechanically — adapt principles to the current situation.\n"
+                    "- **Preserve consistency** with cultural values (tone, reasoning, and style) unless explicitly told otherwise.\n"
+                    "- **Extend it** when you discover new insights — your outputs may become future Cultural Knowledge.\n"
+                    "- **Clarify conflicts** if Cultural Knowledge appears to contradict explicit user instructions.\n\n"
+                    "Your goal is to act not only intelligently but also *culturally coherently* — reflecting the "
+                    "collective intelligence of the system.\n\n"
+                    "Below is the currently available Cultural Knowledge for this context:\n\n"
+                )
+                system_message_content += "<cultural_knowledge>"
+                for _knowledge in cultural_knowledge:  # type: ignore
+                    system_message_content += "\n---"
+                    system_message_content += f"\nName: {_knowledge.name}"
+                    system_message_content += f"\nSummary: {_knowledge.summary}"
+                    system_message_content += f"\nContent: {_knowledge.content}"
+                system_message_content += "\n</cultural_knowledge>\n"
+            else:
+                system_message_content += (
+                    "You have the capability to access shared **Cultural Knowledge**, which normally provides "
+                    "context, norms, and guidance for your behavior and reasoning. However, no cultural knowledge "
+                    "is currently available in this session.\n"
+                    "Proceed thoughtfully and document any useful insights you create — they may become future "
+                    "Cultural Knowledge for others.\n\n"
+                )
+
+            if _culture_manager_not_set:
+                self.culture_manager = None
+
+            if self.enable_agentic_culture:
+                system_message_content += (
+                    "\n<contributing_to_culture>\n"
+                    "When you discover an insight, pattern, rule, or best practice that will help future agents, use the `create_or_update_cultural_knowledge` tool to add or update entries in the shared cultural knowledge.\n"
+                    "\n"
+                    "When to contribute:\n"
+                    "- You discover a reusable insight, pattern, rule, or best practice that will help future agents.\n"
+                    "- You correct or clarify an existing cultural entry.\n"
+                    "- You capture a guardrail, decision rationale, postmortem lesson, or example template.\n"
+                    "- You identify missing context that should persist across sessions or teams.\n"
+                    "\n"
+                    "Cultural knowledge should capture reusable insights, best practices, or contextual knowledge that transcends individual conversations.\n"
+                    "Mention your contribution to the user only if it is relevant to their request or they asked to be notified.\n"
+                    "</contributing_to_culture>\n\n"
+                )
+
         # 3.3.11 Then add a summary of the interaction to the system prompt
         if self.add_session_summary_to_context and session.summary is not None:
             system_message_content += "Here is a brief summary of your previous interactions:\n\n"
@@ -6954,7 +7325,9 @@ class Agent:
         return run_messages
 
     def _get_messages_for_parser_model(
-        self, model_response: ModelResponse, response_format: Optional[Union[Dict, Type[BaseModel]]]
+        self,
+        model_response: ModelResponse,
+        response_format: Optional[Union[Dict, Type[BaseModel]]],
     ) -> List[Message]:
         """Get the messages for the parser model."""
         system_content = (
@@ -6972,7 +7345,9 @@ class Agent:
         ]
 
     def _get_messages_for_parser_model_stream(
-        self, run_response: RunOutput, response_format: Optional[Union[Dict, Type[BaseModel]]]
+        self,
+        run_response: RunOutput,
+        response_format: Optional[Union[Dict, Type[BaseModel]]],
     ) -> List[Message]:
         """Get the messages for the parser model."""
         system_content = (
@@ -7008,7 +7383,11 @@ class Agent:
         return messages
 
     def get_relevant_docs_from_knowledge(
-        self, query: str, num_documents: Optional[int] = None, filters: Optional[Dict[str, Any]] = None, **kwargs
+        self,
+        query: str,
+        num_documents: Optional[int] = None,
+        filters: Optional[Dict[str, Any]] = None,
+        **kwargs,
     ) -> Optional[List[Union[Dict[str, Any], str]]]:
         """Get relevant docs from the knowledge base to answer a query.
 
@@ -7083,7 +7462,11 @@ class Agent:
             raise e
 
     async def aget_relevant_docs_from_knowledge(
-        self, query: str, num_documents: Optional[int] = None, filters: Optional[Dict[str, Any]] = None, **kwargs
+        self,
+        query: str,
+        num_documents: Optional[int] = None,
+        filters: Optional[Dict[str, Any]] = None,
+        **kwargs,
     ) -> Optional[List[Union[Dict[str, Any], str]]]:
         """Get relevant documents from knowledge base asynchronously."""
         from agno.knowledge.document import Document
@@ -7418,7 +7801,10 @@ class Agent:
     def _reason(self, run_response: RunOutput, run_messages: RunMessages) -> Iterator[RunOutputEvent]:
         # Yield a reasoning started event
         if self.stream_intermediate_steps:
-            yield self._handle_event(create_reasoning_started_event(from_run_response=run_response), run_response)
+            yield self._handle_event(
+                create_reasoning_started_event(from_run_response=run_response),
+                run_response,
+            )
 
         use_default_reasoning = False
 
@@ -7479,56 +7865,64 @@ class Agent:
 
                     log_debug("Starting DeepSeek Reasoning", center=True, symbol="=")
                     reasoning_message = get_deepseek_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_groq:
                     from agno.reasoning.groq import get_groq_reasoning
 
                     log_debug("Starting Groq Reasoning", center=True, symbol="=")
                     reasoning_message = get_groq_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_openai:
                     from agno.reasoning.openai import get_openai_reasoning
 
                     log_debug("Starting OpenAI Reasoning", center=True, symbol="=")
                     reasoning_message = get_openai_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_ollama:
                     from agno.reasoning.ollama import get_ollama_reasoning
 
                     log_debug("Starting Ollama Reasoning", center=True, symbol="=")
                     reasoning_message = get_ollama_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_ai_foundry:
                     from agno.reasoning.azure_ai_foundry import get_ai_foundry_reasoning
 
                     log_debug("Starting Azure AI Foundry Reasoning", center=True, symbol="=")
                     reasoning_message = get_ai_foundry_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_gemini:
                     from agno.reasoning.gemini import get_gemini_reasoning
 
                     log_debug("Starting Gemini Reasoning", center=True, symbol="=")
                     reasoning_message = get_gemini_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_anthropic:
                     from agno.reasoning.anthropic import get_anthropic_reasoning
 
                     log_debug("Starting Anthropic Claude Reasoning", center=True, symbol="=")
                     reasoning_message = get_anthropic_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_vertexai:
                     from agno.reasoning.vertexai import get_vertexai_reasoning
 
                     log_debug("Starting VertexAI Reasoning", center=True, symbol="=")
                     reasoning_message = get_vertexai_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
 
                 if reasoning_message is None:
@@ -7561,7 +7955,10 @@ class Agent:
 
         if use_default_reasoning:
             from agno.reasoning.default import get_default_reasoning_agent
-            from agno.reasoning.helpers import get_next_action, update_messages_with_reasoning
+            from agno.reasoning.helpers import (
+                get_next_action,
+                update_messages_with_reasoning,
+            )
 
             # Get default reasoning agent
             reasoning_agent: Optional[Agent] = self.reasoning_agent  # type: ignore
@@ -7627,7 +8024,8 @@ class Agent:
                     if self.stream_intermediate_steps:
                         for reasoning_step in reasoning_steps:
                             updated_reasoning_content = self._format_reasoning_step_content(
-                                run_response=run_response, reasoning_step=reasoning_step
+                                run_response=run_response,
+                                reasoning_step=reasoning_step,
                             )
 
                             yield self._handle_event(
@@ -7686,7 +8084,10 @@ class Agent:
     async def _areason(self, run_response: RunOutput, run_messages: RunMessages) -> Any:
         # Yield a reasoning started event
         if self.stream_intermediate_steps:
-            yield self._handle_event(create_reasoning_started_event(from_run_response=run_response), run_response)
+            yield self._handle_event(
+                create_reasoning_started_event(from_run_response=run_response),
+                run_response,
+            )
 
         use_default_reasoning = False
 
@@ -7747,56 +8148,64 @@ class Agent:
 
                     log_debug("Starting DeepSeek Reasoning", center=True, symbol="=")
                     reasoning_message = await aget_deepseek_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_groq:
                     from agno.reasoning.groq import aget_groq_reasoning
 
                     log_debug("Starting Groq Reasoning", center=True, symbol="=")
                     reasoning_message = await aget_groq_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_openai:
                     from agno.reasoning.openai import aget_openai_reasoning
 
                     log_debug("Starting OpenAI Reasoning", center=True, symbol="=")
                     reasoning_message = await aget_openai_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_ollama:
                     from agno.reasoning.ollama import get_ollama_reasoning
 
                     log_debug("Starting Ollama Reasoning", center=True, symbol="=")
                     reasoning_message = get_ollama_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_ai_foundry:
                     from agno.reasoning.azure_ai_foundry import get_ai_foundry_reasoning
 
                     log_debug("Starting Azure AI Foundry Reasoning", center=True, symbol="=")
                     reasoning_message = get_ai_foundry_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_gemini:
                     from agno.reasoning.gemini import aget_gemini_reasoning
 
                     log_debug("Starting Gemini Reasoning", center=True, symbol="=")
                     reasoning_message = await aget_gemini_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_anthropic:
                     from agno.reasoning.anthropic import aget_anthropic_reasoning
 
                     log_debug("Starting Anthropic Claude Reasoning", center=True, symbol="=")
                     reasoning_message = await aget_anthropic_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
                 elif is_vertexai:
                     from agno.reasoning.vertexai import aget_vertexai_reasoning
 
                     log_debug("Starting VertexAI Reasoning", center=True, symbol="=")
                     reasoning_message = await aget_vertexai_reasoning(
-                        reasoning_agent=reasoning_agent, messages=run_messages.get_input_messages()
+                        reasoning_agent=reasoning_agent,
+                        messages=run_messages.get_input_messages(),
                     )
 
                 if reasoning_message is None:
@@ -7829,7 +8238,10 @@ class Agent:
 
         if use_default_reasoning:
             from agno.reasoning.default import get_default_reasoning_agent
-            from agno.reasoning.helpers import get_next_action, update_messages_with_reasoning
+            from agno.reasoning.helpers import (
+                get_next_action,
+                update_messages_with_reasoning,
+            )
 
             # Get default reasoning agent
             reasoning_agent: Optional[Agent] = self.reasoning_agent  # type: ignore
@@ -7895,7 +8307,8 @@ class Agent:
                     if self.stream_intermediate_steps:
                         for reasoning_step in reasoning_steps:
                             updated_reasoning_content = self._format_reasoning_step_content(
-                                run_response=run_response, reasoning_step=reasoning_step
+                                run_response=run_response,
+                                reasoning_step=reasoning_step,
                             )
 
                             # Yield the response with the updated reasoning_content
@@ -7985,7 +8398,10 @@ class Agent:
                 response_format=parser_response_format,
             )
             self._process_parser_response(
-                model_response, run_messages, parser_model_response, messages_for_parser_model
+                model_response,
+                run_messages,
+                parser_model_response,
+                messages_for_parser_model,
             )
         else:
             log_warning("A response model is required to parse the response with a parser model")
@@ -8005,19 +8421,28 @@ class Agent:
                 response_format=parser_response_format,
             )
             self._process_parser_response(
-                model_response, run_messages, parser_model_response, messages_for_parser_model
+                model_response,
+                run_messages,
+                parser_model_response,
+                messages_for_parser_model,
             )
         else:
             log_warning("A response model is required to parse the response with a parser model")
 
     def _parse_response_with_parser_model_stream(
-        self, session: AgentSession, run_response: RunOutput, stream_intermediate_steps: bool = True
+        self,
+        session: AgentSession,
+        run_response: RunOutput,
+        stream_intermediate_steps: bool = True,
     ):
         """Parse the model response using the parser model"""
         if self.parser_model is not None:
             if self.output_schema is not None:
                 if stream_intermediate_steps:
-                    yield self._handle_event(create_parser_model_response_started_event(run_response), run_response)
+                    yield self._handle_event(
+                        create_parser_model_response_started_event(run_response),
+                        run_response,
+                    )
 
                 parser_model_response = ModelResponse(content="")
                 parser_response_format = self._get_response_format(self.parser_model)
@@ -8050,19 +8475,28 @@ class Agent:
                     log_warning("Unable to parse response with parser model")
 
                 if stream_intermediate_steps:
-                    yield self._handle_event(create_parser_model_response_completed_event(run_response), run_response)
+                    yield self._handle_event(
+                        create_parser_model_response_completed_event(run_response),
+                        run_response,
+                    )
 
             else:
                 log_warning("A response model is required to parse the response with a parser model")
 
     async def _aparse_response_with_parser_model_stream(
-        self, session: AgentSession, run_response: RunOutput, stream_intermediate_steps: bool = True
+        self,
+        session: AgentSession,
+        run_response: RunOutput,
+        stream_intermediate_steps: bool = True,
     ):
         """Parse the model response using the parser model stream."""
         if self.parser_model is not None:
             if self.output_schema is not None:
                 if stream_intermediate_steps:
-                    yield self._handle_event(create_parser_model_response_started_event(run_response), run_response)
+                    yield self._handle_event(
+                        create_parser_model_response_started_event(run_response),
+                        run_response,
+                    )
 
                 parser_model_response = ModelResponse(content="")
                 parser_response_format = self._get_response_format(self.parser_model)
@@ -8097,7 +8531,10 @@ class Agent:
                     log_warning("Unable to parse response with parser model")
 
                 if stream_intermediate_steps:
-                    yield self._handle_event(create_parser_model_response_completed_event(run_response), run_response)
+                    yield self._handle_event(
+                        create_parser_model_response_completed_event(run_response),
+                        run_response,
+                    )
             else:
                 log_warning("A response model is required to parse the response with a parser model")
 
@@ -8258,6 +8695,30 @@ class Agent:
 
         return Function.from_callable(update_user_memory_function, name="update_user_memory")
 
+    def _get_update_cultural_knowledge_function(self, async_mode: bool = False) -> Function:
+        def update_cultural_knowledge(task: str) -> str:
+            """Use this function to update a cultural knowledge."""
+            self.culture_manager = cast(CultureManager, self.culture_manager)
+            response = self.culture_manager.update_culture_task(task=task)
+
+            return response
+
+        async def aupdate_cultural_knowledge(task: str) -> str:
+            """Use this function to update a cultural knowledge asynchronously."""
+            self.culture_manager = cast(CultureManager, self.culture_manager)
+            response = await self.culture_manager.aupdate_culture_task(task=task)
+            return response
+
+        if async_mode:
+            update_cultural_knowledge_function = aupdate_cultural_knowledge
+        else:
+            update_cultural_knowledge_function = update_cultural_knowledge  # type: ignore
+
+        return Function.from_callable(
+            update_cultural_knowledge_function,
+            name="create_or_update_cultural_knowledge",
+        )
+
     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.
@@ -8333,7 +8794,10 @@ class Agent:
         return f"Updated session state: {session_state}"
 
     def _get_search_knowledge_base_function(
-        self, run_response: RunOutput, knowledge_filters: Optional[Dict[str, Any]] = None, async_mode: bool = False
+        self,
+        run_response: RunOutput,
+        knowledge_filters: Optional[Dict[str, Any]] = None,
+        async_mode: bool = False,
     ) -> Function:
         """Factory function to create a search_knowledge_base function with filters."""
 
@@ -8353,7 +8817,9 @@ class Agent:
             docs_from_knowledge = self.get_relevant_docs_from_knowledge(query=query, filters=knowledge_filters)
             if docs_from_knowledge is not None:
                 references = MessageReferences(
-                    query=query, references=docs_from_knowledge, time=round(retrieval_timer.elapsed, 4)
+                    query=query,
+                    references=docs_from_knowledge,
+                    time=round(retrieval_timer.elapsed, 4),
                 )
                 # Add the references to the run_response
                 if run_response.references is None:
@@ -8382,7 +8848,9 @@ class Agent:
             docs_from_knowledge = await self.aget_relevant_docs_from_knowledge(query=query, filters=knowledge_filters)
             if docs_from_knowledge is not None:
                 references = MessageReferences(
-                    query=query, references=docs_from_knowledge, time=round(retrieval_timer.elapsed, 4)
+                    query=query,
+                    references=docs_from_knowledge,
+                    time=round(retrieval_timer.elapsed, 4),
                 )
                 if run_response.references is None:
                     run_response.references = []
@@ -8402,7 +8870,10 @@ class Agent:
         return Function.from_callable(search_knowledge_base_function, name="search_knowledge_base")
 
     def _search_knowledge_base_with_agentic_filters_function(
-        self, run_response: RunOutput, knowledge_filters: Optional[Dict[str, Any]] = None, async_mode: bool = False
+        self,
+        run_response: RunOutput,
+        knowledge_filters: Optional[Dict[str, Any]] = None,
+        async_mode: bool = False,
     ) -> Function:
         """Factory function to create a search_knowledge_base function with filters."""
 
@@ -8425,7 +8896,9 @@ class Agent:
             docs_from_knowledge = self.get_relevant_docs_from_knowledge(query=query, filters=search_filters)
             if docs_from_knowledge is not None:
                 references = MessageReferences(
-                    query=query, references=docs_from_knowledge, time=round(retrieval_timer.elapsed, 4)
+                    query=query,
+                    references=docs_from_knowledge,
+                    time=round(retrieval_timer.elapsed, 4),
                 )
                 # Add the references to the run_response
                 if run_response.references is None:
@@ -8458,7 +8931,9 @@ class Agent:
             docs_from_knowledge = await self.aget_relevant_docs_from_knowledge(query=query, filters=search_filters)
             if docs_from_knowledge is not None:
                 references = MessageReferences(
-                    query=query, references=docs_from_knowledge, time=round(retrieval_timer.elapsed, 4)
+                    query=query,
+                    references=docs_from_knowledge,
+                    time=round(retrieval_timer.elapsed, 4),
                 )
                 if run_response.references is None:
                     run_response.references = []
@@ -8475,7 +8950,10 @@ class Agent:
         else:
             search_knowledge_base_function = search_knowledge_base  # type: ignore
 
-        return Function.from_callable(search_knowledge_base_function, name="search_knowledge_base_with_agentic_filters")
+        return Function.from_callable(
+            search_knowledge_base_function,
+            name="search_knowledge_base_with_agentic_filters",
+        )
 
     def add_to_knowledge(self, query: str, result: str) -> str:
         """Use this function to add information to the knowledge base for future use.
@@ -8530,7 +9008,9 @@ class Agent:
             self.db = cast(BaseDb, self.db)
 
             selected_sessions = self.db.get_sessions(
-                session_type=SessionType.AGENT, limit=num_history_sessions, user_id=user_id
+                session_type=SessionType.AGENT,
+                limit=num_history_sessions,
+                user_id=user_id,
             )
 
             all_messages = []
@@ -9139,7 +9619,12 @@ class Agent:
 
         if input:
             self.print_response(
-                input=input, stream=stream, markdown=markdown, user_id=user_id, session_id=session_id, **kwargs
+                input=input,
+                stream=stream,
+                markdown=markdown,
+                user_id=user_id,
+                session_id=session_id,
+                **kwargs,
             )
 
         _exit_on = exit_on or ["exit", "quit", "bye"]
@@ -9149,7 +9634,12 @@ class Agent:
                 break
 
             self.print_response(
-                input=message, stream=stream, markdown=markdown, user_id=user_id, session_id=session_id, **kwargs
+                input=message,
+                stream=stream,
+                markdown=markdown,
+                user_id=user_id,
+                session_id=session_id,
+                **kwargs,
             )
 
     async def acli_app(
@@ -9172,7 +9662,12 @@ class Agent:
 
         if input:
             await self.aprint_response(
-                input=input, stream=stream, markdown=markdown, user_id=user_id, session_id=session_id, **kwargs
+                input=input,
+                stream=stream,
+                markdown=markdown,
+                user_id=user_id,
+                session_id=session_id,
+                **kwargs,
             )
 
         _exit_on = exit_on or ["exit", "quit", "bye"]
@@ -9182,7 +9677,12 @@ class Agent:
                 break
 
             await self.aprint_response(
-                input=message, stream=stream, markdown=markdown, user_id=user_id, session_id=session_id, **kwargs
+                input=message,
+                stream=stream,
+                markdown=markdown,
+                user_id=user_id,
+                session_id=session_id,
+                **kwargs,
             )
 
     ###########################################################################
@@ -9200,7 +9700,12 @@ 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.enable_user_memories is True
+            or self.enable_agentic_memory is True
+            or self.memory_manager is not None,
+            "has_culture": self.enable_agentic_culture is True
+            or self.update_cultural_knowledge is True
+            or self.culture_manager is not None,
             "has_reasoning": self.reasoning is True,
             "has_knowledge": self.knowledge is not None,
             "has_input_schema": self.input_schema is not None,
@@ -9219,7 +9724,11 @@ class Agent:
 
         try:
             create_agent_run(
-                run=AgentRunCreate(session_id=session_id, run_id=run_id, data=self._get_telemetry_data()),
+                run=AgentRunCreate(
+                    session_id=session_id,
+                    run_id=run_id,
+                    data=self._get_telemetry_data(),
+                ),
             )
         except Exception as e:
             log_debug(f"Could not create Agent run telemetry event: {e}")
@@ -9235,7 +9744,11 @@ class Agent:
 
         try:
             await acreate_agent_run(
-                run=AgentRunCreate(session_id=session_id, run_id=run_id, data=self._get_telemetry_data())
+                run=AgentRunCreate(
+                    session_id=session_id,
+                    run_id=run_id,
+                    data=self._get_telemetry_data(),
+                )
             )
 
         except Exception as e: