Release Notes: v0.11.0¶

Release Date: 2026-06-28

Overview¶

OmniAgent v0.11.0 introduces omnimemory integration for multi-backend semantic memory, OAuth 2.0 SSO for the web UI, and AgentAuth token validation for enterprise authentication. This release focuses on production-ready memory architecture and enterprise security features.

Highlights¶

OmniMemory Integration - Replace omniretrieve with omnimemory for unified memory abstraction supporting multiple backends (PostgreSQL, KVS, Mem0, Twilio Memory)
Automatic Memory Recall - Agent automatically recalls relevant memories before each LLM call and injects them into context
Memory Types & Scopes - Structured memory with types (observation, fact, preference) and scopes (user, agent, session, tenant)
OAuth 2.0 SSO - GitHub and Google authentication for the web UI with email/domain ACL
AgentAuth Integration - Enterprise token validation with ID-JAG + AAuth support
Deployment Guide - Comprehensive guide for containerization and AWS LightSail deployment

New Features¶

OmniMemory Integration¶

Replace omniretrieve with omnimemory for a unified memory abstraction layer:

import (
    "github.com/plexusone/omniagent/agent"
    "github.com/plexusone/omnimemory/core"
)

// Create memory client with PostgreSQL backend
memoryClient, err := core.NewClient(core.ClientConfig{
    Providers: []core.ProviderConfig{
        {Name: core.ProviderNamePostgres, DSN: os.Getenv("DATABASE_URL")},
    },
})

// Create agent with memory
a, err := agent.New(config,
    agent.WithMemory(memoryClient),
)

Or use the convenience option:

a, err := agent.New(config,
    agent.WithMemoryConfig(core.ClientConfig{
        Providers: []core.ProviderConfig{
            {Name: core.ProviderNameMemory}, // In-memory for testing
        },
    }),
)

Memory Providers¶

Provider	Use Case	Registration
`memory`	Testing, development	`core.ProviderNameMemory`
`postgres`	Production with pgvector	`core.ProviderNamePostgres`
`kvs`	SQLite/Redis via omnistorage	`core.ProviderNameKVS`
`mem0`	Mem0 hosted service	`core.ProviderNameMem0`
`twilio`	Twilio Memory API	`core.ProviderNameTwilio`

Automatic Memory Recall¶

The agent automatically recalls relevant memories before each LLM call:

// ProcessWithSession now includes memory recall
response, err := a.ProcessWithSession(ctx, sessionID, "What do you know about my preferences?")

// Internally:
// 1. Recalls relevant memories based on user input
// 2. Injects memories into system prompt
// 3. Processes with LLM
// 4. Returns response

Recalled memories appear in the system prompt:

## Relevant Memories

The following memories have been recalled based on the current context:

1. [preference] User prefers dark mode interfaces
2. [fact] User's timezone is America/New_York
3. [observation] User often asks about weather in the morning

Memory Skill Tools¶

The rewritten memory skill provides these tools:

Tool	Description
`memory_store`	Store information with type, scope, and metadata
`memory_search`	Semantic search with type/scope filters
`memory_recall`	Contextual memory recall with summary
`memory_list`	List memories with pagination
`memory_delete`	Delete memory by ID

Memory Types¶

Type	Description
`observation`	Observed behavior or interaction
`fact`	Verified piece of information
`preference`	User preference
`summary`	Summarized conversation or topic
`trait`	Personality trait or characteristic
`relationship`	Relationship between entities

Memory Scopes¶

Scope	Description
`user`	Personal memories for one user
`agent`	What the agent has learned
`session`	Short-lived conversation memories
`tenant`	Organization-level shared memories
`team`	Group/project level memories
`domain`	Domain-specific (support, sales, etc.)

OAuth 2.0 SSO¶

Add optional OAuth authentication for the web UI:

# Enable OAuth with GitHub
export AUTH_ENABLED=true
export AUTH_SESSION_SECRET=$(openssl rand -hex 32)
export AUTH_GITHUB_CLIENT_ID=your-client-id
export AUTH_GITHUB_CLIENT_SECRET=your-client-secret
export AUTH_ALLOWED_DOMAINS=yourcompany.com

omniagent openai serve

Environment Variables¶

Variable	Description
`AUTH_ENABLED`	Enable authentication (default: false)
`AUTH_SESSION_SECRET`	Cookie signing secret (min 32 bytes)
`AUTH_GITHUB_CLIENT_ID`	GitHub OAuth client ID
`AUTH_GITHUB_CLIENT_SECRET`	GitHub OAuth client secret
`AUTH_GOOGLE_CLIENT_ID`	Google OAuth client ID
`AUTH_GOOGLE_CLIENT_SECRET`	Google OAuth client secret
`AUTH_ALLOWED_EMAILS`	Comma-separated allowed emails
`AUTH_ALLOWED_DOMAINS`	Comma-separated allowed domains

AgentAuth Token Validation¶

Enterprise authentication via AgentAuth (ID-JAG + AAuth):

import "github.com/plexusone/omniagent/api/openai"

server := openai.NewServer(config,
    openai.WithAgentAuth(agentauth.Config{
        IssuerURL: "https://peopleserver.example.com",
        Audience:  "omniagent",
    }),
)

Environment-based configuration:

export AUTH_AAUTH_ENABLED=true
export AUTH_AAUTH_ISSUER=https://peopleserver.example.com
export AUTH_AAUTH_AUDIENCE=omniagent

User Profile in Web UI¶

When OAuth is enabled, the sidebar displays the authenticated user:

User name and email
Avatar (if provided by OAuth provider)
Logout button

New Agent Options¶

Option	Description
`WithMemory(client)`	Set omnimemory client for semantic memory
`WithMemoryConfig(cfg)`	Create omnimemory client from configuration

New Server Options¶

Option	Description
`WithAgentAuth(cfg)`	Enable AgentAuth token validation
`WithAAuth(cfg)`	Enable AAuth token validation (legacy)

Configuration Changes¶

New Fields¶

Field	Type	Description
`memory.enabled`	bool	Enable omnimemory integration
`memory.provider`	string	Provider: memory, postgres, kvs, mem0, twilio
`memory.dsn`	string	Database connection string (postgres)
`memory.api_key`	string	API key (mem0, twilio)
`memory.tenant_id`	string	Default tenant for this agent
`memory.agent_id`	string	Agent identifier
`memory.recall_max`	int	Max memories to recall per request (default: 5)
`memory.embedder.provider`	string	Embedding provider (openai, etc.)
`memory.embedder.model`	string	Embedding model

Memory Configuration¶

memory:
  enabled: true
  provider: postgres
  dsn: ${DATABASE_URL}
  tenant_id: my-tenant
  agent_id: my-agent
  recall_max: 5
  embedder:
    provider: openai
    model: text-embedding-3-small
    api_key: ${OPENAI_API_KEY}

Agent Config Fields¶

Field	Type	Description
`agent.tenant_id`	string	Tenant ID for memory context
`agent.agent_id`	string	Agent ID for memory attribution

Architecture Changes¶

OmniMemory Replaces OmniRetrieve¶

Before v0.11.0:

import "github.com/plexusone/omniretrieve/memory"

manager := memory.NewManager(memory.ManagerConfig{
    Embedder: embedder,
})

After v0.11.0:

import "github.com/plexusone/omnimemory/core"

client, err := core.NewClient(core.ClientConfig{
    Providers: []core.ProviderConfig{
        {Name: core.ProviderNamePostgres, DSN: dsn},
    },
    Embedder: embedder,
})

Memory Skill Changes¶

The memory skill now uses omnimemory client instead of omniretrieve manager:

memory_collections tool removed (replaced with scope filtering)
Added memory_recall tool for contextual recall
Added type and scope parameters to all tools

Dependency Updates¶

Package	From	To
`omnimemory`	-	v0.1.0 (new)
`omniretrieve`	v0.3.0	removed
`agentauth`	-	v0.2.0 (new)
`anthropic-sdk-go`	v1.51.0	v1.52.0
`google.golang.org/api`	v0.285.0	v0.286.0
`google.golang.org/genai`	v1.61.0	v1.62.0
`gorilla/sessions`	-	v1.4.0 (new)
`golang.org/x/oauth2`	-	v0.36.0 (new)

Upgrade Guide¶

From v0.10.0¶

Update your dependency:

go get github.com/plexusone/omniagent@v0.11.0
go mod tidy

(Breaking) Update memory skill imports:

// Before
import "github.com/plexusone/omniretrieve/memory"

// After
import "github.com/plexusone/omnimemory/core"

(Optional) Add memory configuration:

memory:
  enabled: true
  provider: memory  # or: postgres, kvs
  tenant_id: my-tenant

(Optional) Enable OAuth SSO:

export AUTH_ENABLED=true
export AUTH_SESSION_SECRET=$(openssl rand -hex 32)
export AUTH_GITHUB_CLIENT_ID=...
export AUTH_GITHUB_CLIENT_SECRET=...

Breaking Changes¶

Memory skill API changed: The memory skill now uses omnimemory types instead of omniretrieve. If you were using the memory skill programmatically, update your imports.
memory_collections tool removed: Use scope filtering with memory_list instead.

Documentation¶

New guides added:

Web UI Authentication - OAuth 2.0 SSO setup
Deployment Guide - Containerization and AWS deployment
Observability Integration - Building observability hooks

Updated guides:

Memory Skill - Updated for omnimemory
Configuration Reference - Memory and auth config
Environment Variables - Auth variables

Full Changelog¶

See CHANGELOG.md for the complete list of changes.