Memory & Knowledge

Active Development

The memory system core is working. Knowledge ingestion from external sources (Confluence) is implemented; additional connectors are planned. See Roadmap.

Aether's memory system lets agents retain knowledge across task executions and search for relevant context automatically. Instead of starting each task cold, agents draw on accumulated memories and ingested documentation.

How Memory Works

When an agent processes a task:

1. Automatic recall — Aether runs a semantic search over the agent's memory using the task content as the query
2. Context injection — The most relevant memories are automatically added to the agent's system prompt
3. Processing — The LLM processes the task with both its system prompt and the recalled memories
4. Optional storage — The agent (or the system) can store new memories from the task result

This happens transparently — you don't need to do anything special to enable memory for built-in agents.

Memory Tiers

Tier	Storage	Duration	Purpose
Short-term	Redis	Minutes to hours	Current task context, conversation state
Long-term	PostgreSQL	Permanent	Decisions, insights, project knowledge
Semantic search	pgvector	Permanent	Find relevant memories by meaning
Full-text search	PostgreSQL	Permanent	Find memories by exact keywords

Memory Scopes

Memories are scoped to control visibility:

Scope	Visible To	Use For
task	One specific task execution	Temporary task state
agent	One agent across all tasks	Agent-specific knowledge
project	All agents on one project	Project decisions and context
organizational	All agents, all projects	Company-wide knowledge

Searching Memories (API)

Search memories using natural language:

curl -X POST http://localhost:8000/api/memory/search \
  -H "Content-Type: application/json" \
  -d '{
    "query": "authentication and session management decisions",
    "agent_id": "ta_leo",
    "limit": 5
  }'

[
  {
    "key": "auth-decision-jan-2026",
    "content": "Team decided to use JWT with 15-minute expiry and HttpOnly refresh cookies",
    "similarity": 0.94,
    "scope": "project",
    "created_at": "2026-01-15T10:00:00Z"
  },
  {
    "key": "session-timeout-decision",
    "content": "Session timeout set to 30 minutes for inactivity",
    "similarity": 0.87,
    "scope": "project",
    "created_at": "2026-01-10T14:00:00Z"
  }
]

Search parameters:

Parameter	Description
query	Natural language search query
agent_id	Filter to a specific agent's memories
project_id	Filter to a specific project's memories
limit	Maximum results (default: 10)

Storing Memories (API)

Store important decisions or context manually:

curl -X POST http://localhost:8000/api/memory \
  -H "Content-Type: application/json" \
  -d '{
    "key": "database-decision-feb-2026",
    "content": "Chose PostgreSQL over MongoDB for ACID compliance and complex query support. MongoDB evaluated but lacked transaction support needed for financial data.",
    "agent_id": "ta_leo",
    "scope": "project"
  }'

Use descriptive, meaningful keys — they must be unique. If a key already exists, the store will update the content.

Listing Memories (API)

# All memories
curl http://localhost:8000/api/memory

# Filtered by agent
curl "http://localhost:8000/api/memory?agent_id=ta_leo"

# Filtered by scope
curl "http://localhost:8000/api/memory?scope=project"

Deleting Memories (API)

curl -X DELETE http://localhost:8000/api/memory/database-decision-feb-2026

Knowledge Ingestion

Beyond individual memories, Aether can ingest entire documentation sources and make them searchable by agents.

Confluence (Working)

Aether can connect to a Confluence Cloud or Server instance and ingest pages as searchable knowledge:

1. Add a knowledge source via API:

   curl -X POST http://localhost:8000/api/knowledge-sources \
     -H "Content-Type: application/json" \
     -d '{
       "type": "confluence",
       "name": "Company Wiki",
       "config": {
         "base_url": "https://yourcompany.atlassian.net/wiki",
         "api_token": "your-confluence-token",
         "space_key": "ENG"
       }
     }'

2. Trigger ingestion — Aether fetches pages, splits them into chunks, generates embeddings, and stores them for semantic search.

3. Incremental sync — Subsequent ingestions only process pages modified since the last sync.

Once ingested, Confluence content is searchable alongside regular memories. Agents automatically receive relevant documentation as context.

Other Connectors

• WikiJS, BookStack, raw HTML — Planned. See Roadmap.

Memory via the Frontend

The Memory section in the Aether frontend lets you:

• Search memories with a natural language query
• View all stored memories with filtering
• Manually add new memories
• Delete individual memories

Configuration

# Embedding model for semantic search (required for semantic memory)
EMBEDDING_MODEL=text-embedding-3-small
EMBEDDING_DIMENSION=1536

# Max results returned by automatic memory injection
MEMORY_SEARCH_LIMIT=10

Tips

• Store decisions explicitly — When agents make important architectural or design decisions, store them as memories with a clear key so they're available in future tasks.

• Use organizational scope for company standards — Coding standards, security policies, and architectural patterns should be in organizational scope so all agents benefit.

• Use project scope for project context — Project-specific tech stack choices, conventions, and decisions belong in project scope.

• Be specific in queries — When searching, more specific queries return more relevant results. "JWT authentication refresh token strategy" works better than "auth".

See Also

• Agent Memory System (Developer Docs) — Architecture and implementation details
• Agent Runtime Protocol — Memory access via gRPC for external agents
• REST API: Memory — Full API reference