Mastering Session State & Memory in Multi-Agent Networks

When multiple specialized AI agents cooperate within a network ecosystem, maintaining a unified source of truth for session memory is essential to prevent conflicting agent states or token context bloat.

The Multi-Agent State Synchronization Pattern

Google ADK resolves data race conditions by utilizing the **InMemoryRunner context orchestration model**. Instead of letting each sub-agent build isolated history logs, execution sessions are unified under a central orchestrator memory ring. This allows peer agents to share variables dynamically without cross-contaminating their unique system instructions.

Implementation: Building a State-Managed Memory Pipeline

Let's implement a clean reactive pipeline within an Android architecture component using Kotlin Coroutines and asynchronous StateFlow streams.

package com.example.adkdemoapp.state

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.adkdemoapp.agents.PrimaryRouterAgent
import com.google.adk.kt.runners.InMemoryRunner
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch

class MultiAgentSessionViewModel : ViewModel() {

    private val _sessionLogs = MutableStateFlow<List<String>>(emptyList())
    val sessionLogs: StateFlow<List<String>> = _sessionLogs

    // Initializing a secure, non-persistent local runtime memory session context
    private val memoryRunner = InMemoryRunner.create(
        rootAgent = PrimaryRouterAgent.orchestrator
    )

    fun dispatchSynchronizedMessage(userPrompt: String) {
        viewModelScope.launch {
            // Pre-append prompt context token smoothly
            _sessionLogs.value = _sessionLogs.value + "User: $userPrompt"

            try {
                // Propagating contextual metrics downstream into the multi-agent network
                val responseStringBuilder = StringBuilder()
                
                memoryRunner.executeStream(userPrompt).collect { chunk ->
                    responseStringBuilder.append(chunk.textDelta)
                }

                _sessionLogs.value = _sessionLogs.value + "Network Swarm: $responseStringBuilder"
            } catch (e: Exception) {
                _sessionLogs.value = _sessionLogs.value + "State Error: ${e.localizedMessage}"
            }
        }
    }
}

Defending Against State Collisions

• Unidirectional Context Flow: Avoid updating the same metadata variable simultaneously from different background workers. Designate your primary root routing node as the sole authority for mutating global states.
• Explicit Session Resets: Clear out the InMemoryRunner instance when the user completes their session checklist or signs out to prevent context bleed into subsequent app use cycles.