From Autonomous Agents to Cognitive Symbionts: Toward AI-Augmented Human Intelligence

Core Concept: Cognitive Symbionts§

The paper introduces AI-augmented human intelligence (AHI) as a complement to AGI, focusing on how AI can enhance a specific person's intelligence rather than replace it. The central idea is the cognitive symbiont: a lifelong, embedded, real-time, private, low-friction, and proactive companion that senses, remembers, understands, acts, and thinks with the user.

The Cognitive Gap§

The paradigm is motivated by the cognitive gap between what a person could bring to a situation (their full knowledge and history) and what they can actually hold in working memory. Formally, if $K$ is the person's total knowledge and $W$ is working memory capacity, the gap is:

$$G = K - W$$

A symbiont aims to reduce $G$ by providing external cognitive support.

Symbiosis Loop§

The design space is organized as a symbiosis loop with seven stages:

1. Sensing: Perceive the person's environment and physiological signals via external devices.
2. Keeping: Maintain a persistent memory of the person's context over years.
3. Understanding: Model the person's situation and mental state.
4. Living alongside: Integrate seamlessly into daily life.
5. Acting for: Perform tasks on behalf of the person with their context.
6. Thinking with: Engage in joint cognitive processes at the right moment.
7. Growing: Continuously learn and adapt as both person and AI evolve.

This loop is enclosed by a personal runtime (ensuring privacy and low latency) and trust (governance and transparency).

Implementation Sketch§

A cognitive symbiont can be implemented as a modular system with a central LLM orchestrating specialized components. Below is a simplified PyTorch-style pseudocode illustrating the architecture:

import torch
import torch.nn as nn

class CognitiveSymbiont(nn.Module):
    def __init__(self, llm, memory_size=1000000, embedding_dim=768):
        super().__init__()
        self.llm = llm  # Large Language Model backbone
        self.memory = VectorDatabase(memory_size, embedding_dim)  # Persistent memory
        self.sensor_fusion = SensorFusion()  # Processes multimodal sensor data
        self.user_model = UserModel(embedding_dim)  # Models user's knowledge and state
        self.policy = ProactivePolicy(embedding_dim)  # Decides when to intervene

    def forward(self, sensor_data, user_query=None):
        # 1. Sensing: process raw sensor data
        percepts = self.sensor_fusion(sensor_data)
        
        # 2. Keeping: retrieve relevant memories
        context = self.memory.retrieve(percepts, top_k=5)
        
        # 3. Understanding: update user model
        user_state = self.user_model.update(percepts, context)
        
        # 4. Thinking with: generate response if needed
        if self.policy.should_intervene(user_state, user_query):
            prompt = self._build_prompt(percepts, context, user_state, user_query)
            response = self.llm.generate(prompt)
        else:
            response = None
        
        # 5. Growing: store new experience
        self.memory.store(percepts, response)
        
        return response

Risks and Governance§

The paper highlights new risks such as covert assistance (e.g., in examinations) and social pressure to adopt the technology. Governance mechanisms must ensure transparency, consent, and equitable access.

Conclusion§

Cognitive symbionts represent a shift from autonomous agents to AI that augments human cognition. By closing the cognitive gap, they promise to enhance human potential while requiring careful design of privacy, trust, and governance.