🚀 Feature Request: Agno Shared State

[aniya105]

🎤 Tell us your idea

I hope that when using agno, you can use the bidirectional state synchronization function like Langgraph

[copilotkit-support-bot]

AgNo supports bidirectional state synchronization similar to LangGraph, including a shared state feature. This allows both the agent and UI to update and reflect changes in real time.

Details

✅ Bidirectional State Synchronization

• useCoAgent Hook: AgNo provides bidirectional reactivity where "changes to the state from the agent will be reflected in the UI and vice versa"

• CoAgent State Sharing: CoAgents have bi-directional state sharing between the agent and UI, allowing:

• Agents to remember information from previous messages
• UI to update the agent with new information

✅ Shared State Feature

• Active Implementation: AgNo concepts documentation mentions "shared state updates once the operation is complete" with links to predictive state updates

• Live Demos: AgNo is marked as "✅ Supported" in the AG-UI protocol with working shared state demos available at: dojo.ag-ui.com/agno/feature/shared_state

Technical Implementation

• Same Foundation: Both AgNo and LangGraph use the same underlying AG-UI protocol for bidirectional state synchronization through CopilotKit

• Unified Hook: Both frameworks utilize the same useCoAgent hook to create bidirectional connections between application state and agent state

Documentation References

• AgNo State Concepts - State management and shared updates
• AgNo Framework Integration - Bi-directional state sharing details
• useCoAgent Hook Reference - Implementation details
• LangGraph Shared State Tutorial - Comparative implementation

Confidence Level: High - AgNo has equivalent bidirectional state synchronization capabilities to LangGraph with active implementation and live examples.

---

Was this helpful?

If this solution worked for you, please click on the appropriate option below to help us improve:

✅ Issue Solved | ❌ Need more help

[Reknine]

+1

[joeychrys]

+1

[spancer]

+1

I’ve noticed that the AG-UI protocol already has an integration middleware for Google ADK (ag-ui-adk). This middleware enables bidirectional synchronization between Agent state and UI, significantly simplifying the implementation of the interaction layer for Agents built with ADK.

[spancer]

I'm trying to implement https://github.com/CopilotKit/adk-generative-dashboard using Agno. After all, Agno offers excellent performance and scalability in agent and workflow development, and our project currently uses Agno as the core technology stack for agent development.
When attempting to replace the ADK implementation with Agno, I noticed that the adk-generative-dashboard project relies heavily on bidirectional data communication between CopilotKit and the agent. Data in the agent (metrics, charts) is shared with the frontend in real-time through context, enabling seamless interaction and collaboration between the frontend and backend throughout the dashboard construction process—all thanks to the shared agent state.
However, Agno lacks a middleware layer similar to https://github.com/ag-ui-protocol/ag-ui/tree/main/integrations/adk-middleware, which handles state sharing between the agent and CopilotKit. Therefore, when using Agno with CopilotKit, we can only rely on the official examples that use backend_tool_rendering or tool_based_generative_ui. After the backend Agno generates data, the frontend must retrieve it using useCopilotAction. While this is achievable (whether using backend_tool_rendering or tool_based_generative_ui requires defining numerous corresponding frontend functions and backend tools with matching names, which is somewhat cumbersome), the most frustrating issue arises when the frontend needs to update state data and notify the backend after certain operations. This becomes very cumbersome and is essentially impossible to implement elegantly.
For example, one could define a Redis-based API for the frontend to call and update data, but with complex pages and frequent interactions, it's easy to encounter various errors when the frontend fetches data (using useCopilotAction) or sends back/responds with data. These include issues like incorrect data formats for returned data (e.g., "An assistant message with 'tool_calls' must be followed by tool messages responding to each 'tool_call_id'") or disruptions to the execution order of the backend LLM (e.g., the LLM might be waiting for feedback from tool A while the frontend suddenly updates the state related to tool B). This can be extremely problematic.
Therefore, I believe it would be beneficial to implement a middleware similar to ADK's, perhaps named agno-middleware.

[joeychrys]

This shouldn't be closed

[Reknine]

+1