Agent Learn

Continuous learning system for capturing patterns, preferences, and insights from agent interactions

Agent Learn enables agents to capture and recall patterns, preferences, and insights from interactions, improving future responses through persistent learning stores.

Quick Start

1. Simple Shorthand (Recommended)

   The easiest way to enable Agent Learn:

   from praisonaiagents import Agent
   
   agent = Agent(
       name="Learning Agent",
       instructions="You are a helpful assistant that learns from interactions",
       learn=True  # Enables AGENTIC mode (auto-learning)
   )
   
   agent.start("What's my preferred coding style?")
   

   learn=True is a top-level Agent parameter — peer to memory=. It auto-creates a minimal memory backend if needed.

2. With Specific Capabilities

   from praisonaiagents import Agent, LearnConfig
   
   agent = Agent(
       name="Learning Agent",
       instructions="You learn and adapt to user preferences",
       learn=LearnConfig(
           persona=True,      # User preferences
           insights=True,     # Observations
           patterns=True,     # Reusable knowledge
           decisions=True,    # Decision logging
       )
   )
   
3. All 7 Stores (Full Learning)

   from praisonaiagents import Agent, LearnConfig
   
   # Enable all 7 learning stores for comprehensive learning
   agent = Agent(
       name="Full Learning Agent",
       instructions="You are a comprehensive learner",
       learn=LearnConfig(
           persona=True,       # User preferences & profile
           insights=True,      # Observations & learnings
           thread=True,        # Session context
           patterns=True,      # Reusable knowledge
           decisions=True,     # Decision rationale
           feedback=True,      # Outcome signals
           improvements=True,  # Self-improvement proposals
       )
   )
   

---

How It Works

Auto-Injection: When learn=True is enabled, learned context is automatically injected into the agent’s system prompt before each response. No manual wiring needed!

Phase	Description
Retrieve	get_learn_context() fetches learnings from all enabled stores
Auto-Inject	Context automatically added to system prompt as “Learned Context” section
Generate	Agent uses learned context to personalize response
Persist	Learnings stored in JSON files for cross-session persistence

---

What Gets Injected

When learn=True is enabled, the agent’s system prompt automatically includes a “Learned Context” section with:

## Learned Context

### User Persona
- Prefers dark mode and vim keybindings
- Senior developer working on Python projects

### Insights  
- User values concise, technical responses
- Prefers code examples over lengthy explanations

### Patterns
- Common workflow: test → implement → refactor
- Prefers pytest over unittest

### Decisions
- Chose PostgreSQL over MySQL for type safety
- Selected FastAPI for async performance

### Feedback
- Positive: step-by-step debugging approach
- Improvement: add more context in error messages

### Improvements
- Consider caching frequent queries
- Add retry logic for API calls

Each section only appears if the corresponding store is enabled AND contains data. Thread context is excluded from injection as it’s session-specific.

---

Learning Stores

Agent Learn organizes knowledge into specialized stores:

Store	Purpose	Default
persona	User preferences, communication style, profile	True
insights	Observations and learnings from interactions	True
thread	Session and conversation context	True
patterns	Reusable knowledge patterns	False
decisions	Decision logging and rationale	False
feedback	Outcome signals and corrections	False
improvements	Self-improvement proposals	False

---

Configuration Options

from praisonaiagents import LearnConfig

config = LearnConfig(
    # Learning capabilities
    persona=True,           # User preferences and profile
    insights=True,          # Observations and learnings
    thread=True,            # Session/conversation context
    patterns=False,         # Reusable knowledge patterns
    decisions=False,        # Decision logging
    feedback=False,         # Outcome signals
    improvements=False,     # Self-improvement proposals
    
    # Scope configuration
    scope="private",        # "private" or "shared"
    
    # Storage
    store_path=None,        # Custom storage path
    
    # Maintenance
    auto_consolidate=True,  # Auto-consolidate learnings
    retention_days=None,    # Days to retain (None = forever)
)

Option	Type	Default	Description
persona	bool	True	Capture user preferences and profile
insights	bool	True	Store observations and learnings
thread	bool	True	Maintain session context
patterns	bool	False	Store reusable knowledge patterns
decisions	bool	False	Log decisions with rationale
feedback	bool	False	Capture outcome signals
improvements	bool	False	Track self-improvement proposals
scope	str	"private"	Learning visibility: "private" or "shared"
store_path	str	None	Custom storage directory
auto_consolidate	bool	True	Automatically consolidate learnings
retention_days	int	None	Days to retain entries (None = forever)

---

CLI Commands

Manage learning data via the command line:

Show Status

praisonai memory learn status --user-id default

Show Learned Entries

# Show all stores
praisonai memory learn show all --limit 10

# Show specific store
praisonai memory learn show persona --user-id default

Add Learning Entry

# Add to insights store
praisonai memory learn add "User prefers concise responses" --store insights

# Add to persona store
praisonai memory learn add "Prefers Python over JavaScript" --store persona

Search Learnings

praisonai memory learn search "coding style" --limit 5

Clear Learnings

# Clear all stores
praisonai memory learn clear all --force

# Clear specific store
praisonai memory learn clear persona --user-id default

---

Common Patterns

Personal Assistant with Memory

from praisonaiagents import Agent, MemoryConfig, LearnConfig

agent = Agent(
    name="Personal Assistant",
    instructions="You are a personal assistant that remembers user preferences",
    memory=MemoryConfig(
        backend="sqlite",
        user_id="user123",
        learn=LearnConfig(
            persona=True,
            insights=True,
            patterns=True,
        )
    )
)

# First interaction
agent.start("I prefer dark mode and vim keybindings")

# Later interaction - agent remembers preferences
agent.start("Set up my development environment")

Team Knowledge Base

from praisonaiagents import Agent, MemoryConfig, LearnConfig

agent = Agent(
    name="Team Knowledge Agent",
    instructions="You help the team by learning from shared experiences",
    memory=MemoryConfig(
        learn=LearnConfig(
            scope="shared",      # Share learnings across team
            patterns=True,       # Capture reusable patterns
            decisions=True,      # Log architectural decisions
            improvements=True,   # Track improvement proposals
        )
    )
)

Feedback-Driven Learning

from praisonaiagents import Agent, MemoryConfig, LearnConfig

agent = Agent(
    name="Adaptive Agent",
    instructions="You improve based on feedback",
    memory=MemoryConfig(
        learn=LearnConfig(
            feedback=True,       # Capture outcome signals
            improvements=True,   # Track self-improvement
            auto_consolidate=True,
        )
    )
)

---

Active Learning Tools

For agents that need explicit control over what they learn and recall, use the store_learning and search_learning tool functions — the Learn system counterparts to store_memory / search_memory.

from praisonaiagents import Agent
from praisonaiagents.tools import store_learning, search_learning

agent = Agent(
    instructions="You learn user preferences.",
    memory=True,
    learn=True,
    tools=[store_learning, search_learning],
)

agent.start("I prefer bullet-point answers")
# Agent calls store_learning("prefers bullet-point answers", category="persona")

agent.start("How do I like my answers?")
# Agent calls search_learning("answer format") → recalls "bullet-point answers"

store_learning

Store a learning entry in the agent’s learn system.

Parameter	Type	Required	Default	Description
content	str	Yes	—	The learning to store
category	str	No	"persona"	Category: persona, insights, patterns, decisions, feedback, improvements

search_learning

Search previously stored learnings.

Parameter	Type	Required	Default	Description
query	str	Yes	—	Search query
limit	int	No	5	Max results to return

These tools use Injected[AgentState] — the learn_manager is automatically provided at runtime. No manual wiring needed.

---

Best Practices

Use private scope for personal data

Keep scope="private" (default) when storing user-specific preferences or sensitive information. Use scope="shared" only for team knowledge that should benefit all agents.

Enable stores incrementally

Start with the default stores (persona, insights, thread) and enable additional stores (patterns, decisions, feedback, improvements) as your use case requires them.

Set retention for transient data

Use retention_days for stores that capture temporal patterns. Thread context often benefits from 7-30 day retention to avoid clutter.

Consolidate periodically

Keep auto_consolidate=True to automatically merge and summarize learnings over time, preventing store bloat.

---

Related

Agent Train

Active iterative training

Learn vs Train

Compare passive learning vs active training

Memory

Understanding agent memory systems

Knowledge

RAG and knowledge retrieval