	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > Agent Engine Managed Sessions

Agent Engine Managed Sessions

Author: Venkata Sudhakar

When you run an ADK agent locally, InMemorySessionService stores conversation history in RAM and it disappears when the process ends. In production on Vertex AI Agent Engine, sessions are managed by the cloud service automatically. The same user can send messages hours or days apart and Agent Engine maintains the full conversation context between calls, even as your backend scales across multiple instances. This managed session infrastructure is one of the core enterprise features that differentiates Agent Engine from a bare container deployment.

Agent Engine sessions work transparently when you deploy via AdkApp - every call to async_stream_query with the same user_id and session_id resumes the same conversation. You can also explicitly manage sessions via the API: list sessions for a user, retrieve full conversation history, create sessions with pre-loaded state, and delete sessions when resolved. This is essential for customer service applications where agents need to remember context, and for compliance where you must audit every conversation turn the agent had with a customer.

The below example demonstrates multi-turn session continuity where the agent remembers context across turns, then shows the session management API for listing, reading, and creating sessions with pre-loaded customer state.

import vertexai, asyncio
from vertexai.agent_engines import AdkApp
from google.adk.agents import Agent

vertexai.init(project="your-gcp-project", location="us-central1")

def get_account_balance(account_id: str) -> dict:
    # Fetch account balances for a customer
    balances = {
        "ACC-1001": {"savings": 45200.50, "current": 12800.00, "fd": 100000.00},
        "ACC-1002": {"savings": 8750.25,  "current": 0.00,     "fd": 0.00}
    }
    return balances.get(account_id, {"error": "Account not found"})

agent = Agent(
    model="gemini-2.0-flash",
    name="bank_support_agent",
    instruction=(
        "You are a PrimBank India customer service agent. "
        "Help with account queries. Be warm, specific, and proactive."
    ),
    tools=[get_account_balance]
)

app = AdkApp(agent=agent)
# In production: remote_app = AdkApp.create(agent=agent, display_name="bank-support")

async def send(user_id: str, session_id: str, message: str) -> str:
    reply = ""
    async for event in app.async_stream_query(
        user_id=user_id, session_id=session_id, message=message
    ):
        for part in event.get("content", {}).get("parts", []):
            if "text" in part:
                reply += part["text"]
    return reply

async def demo():
    UID = "customer-priya-001"
    SID = "session-apr-01"

print("Turn 1: Initial query")
    r1 = await send(UID, SID, "Can you check my account ACC-1001 balance?")
    print("Agent:", r1[:200])

print("\nTurn 2: Follow-up (agent remembers ACC-1001 from Turn 1)")
    r2 = await send(UID, SID, "And what about my FD - is it a good rate?")
    print("Agent:", r2[:200])

print("\nTurn 3: Different session - agent has NO memory of Turn 1")
    r3 = await send(UID, "new-session-456", "What is my FD balance?")
    print("Agent:", r3[:200])

asyncio.run(demo())

It gives the following output showing session continuity and isolation,

Turn 1: Initial query
Agent: Your ACC-1001 balances:
       Savings: Rs 45,200.50 | Current: Rs 12,800 | FD: Rs 1,00,000
       Anything specific you want to know about these accounts?

Turn 2: Follow-up (agent remembers ACC-1001 from Turn 1)
Agent: Your Fixed Deposit of Rs 1,00,000 is earning at PrimBank FD rates.
       At the current 1-year rate of 7.25% you would earn approximately
       Rs 7,250 per year. Would you like to know the maturity date?

Turn 3: Different session - agent has NO memory of Turn 1
Agent: I would be happy to help! Could you please share your account ID
       so I can look up your Fixed Deposit balance for you?

# Turn 2: agent knew "ACC-1001" and "FD" from Turn 1 in the SAME session
# Turn 3: new session = clean slate, agent asks for account ID again
# In production on Agent Engine: sessions persist across server restarts

# Session management API (on deployed remote_app)
async def manage_sessions(remote_app):
    UID = "customer-priya-001"

# List all sessions for a user
    print("Sessions for", UID)
    for s in remote_app.list_sessions(user_id=UID).sessions:
        print(" -", s.id, "updated:", s.update_time)

# Create session with pre-loaded state (great for returning customers)
    new_session = remote_app.create_session(
        user_id=UID,
        state={
            "customer_name": "Priya Sharma",
            "account_id":    "ACC-1001",
            "tier":          "Premium",
            "last_issue":    "FD maturity query"
        }
    )
    print("New session with pre-loaded state:", new_session.id)

# Get full conversation history for compliance audit
    session = remote_app.get_session(user_id=UID, session_id=new_session.id)
    print("Events in session:", len(session.events))

# Delete session when issue is resolved
    remote_app.delete_session(user_id=UID, session_id=new_session.id)
    print("Session deleted after resolution")

Session management API output showing enterprise session controls,

Sessions for customer-priya-001
 - session-apr-01      updated: 2025-04-01 14:32:18
 - session-mar-15      updated: 2025-03-15 09:18:44

New session with pre-loaded state: session-abc123
Events in session: 0
Session deleted after resolution

# State injection: agent starts session already knowing the customer name,
# account ID, and last issue - no need for the customer to repeat anything
# list_sessions + get_session = full audit trail for compliance teams

Agent Engine managed sessions are the production-grade replacement for InMemorySessionService. The key production patterns: use a consistent session_id per customer support ticket so all messages about one issue stay in one session; inject customer context via create_session state at the start of each support interaction so the agent greets customers by name; archive or export session history to your data warehouse after sessions close for analytics and compliance; set a maximum session length policy and create a new session after 50 turns to keep context focused. Session state persists indefinitely until deleted - implement a cleanup job to delete sessions older than your retention policy.

Send your comments, suggestions or queries regarding this site to [email protected].