Self-correcting agents

When an agent gets a query wrong, the fix shouldn’t live in your head. Agno’s LearningMachine diagnoses the error, saves the correction as a learning, and pulls it back into context the next time a similar question comes in.

from agno.agent import Agent
from agno.db.postgres import PostgresDb
from agno.knowledge.knowledge import Knowledge
from agno.learn import LearningMachine
from agno.models.openai import OpenAIResponses
from agno.tools.sql import SQLTools
from agno.vectordb.pgvector import PgVector

db_url = "postgresql+psycopg://ai:ai@localhost:5532/ai"

knowledge = Knowledge(
    vector_db=PgVector(table_name="agent_learnings", db_url=db_url),
)

agent = Agent(
    model=OpenAIResponses(id="gpt-5.5"),
    db=PostgresDb(db_url=db_url),
    tools=[SQLTools(db_url="postgresql+psycopg://readonly@warehouse/analytics")],
    learning=LearningMachine(knowledge=knowledge, decision_log=True),
    instructions="When a query errors, diagnose the cause and record the correction.",
)

Passing knowledge to the LearningMachine enables the Learned Knowledge store, where corrections live. decision_log=True records the reasoning behind each change. The agent accumulates corrections across runs and pulls the relevant ones into context on future questions.

The loop

The agent writes SQL and runs it.
It errors, or returns a number a human flags as wrong.
The agent diagnoses the cause (wrong column, stale table, a join that double-counts).
The fix is saved as a learning.
The next similar question retrieves that learning before generating SQL.

Each diagnosed error is written down and pulled back before the next similar query, so recurring errors stop recurring: the agent accumulates what your warehouse’s sharp edges are.

Choose how learning happens

Each store takes a mode. For a data agent, you usually want errors captured automatically and schema changes proposed for review.

from agno.learn import LearnedKnowledgeConfig, LearningMachine, LearningMode

agent = Agent(
    model=OpenAIResponses(id="gpt-5.5"),
    db=db,
    learning=LearningMachine(
        knowledge=knowledge,
        learned_knowledge=LearnedKnowledgeConfig(mode=LearningMode.ALWAYS),
    ),
)

Mode	Behavior	Use for
`ALWAYS`	Capture runs automatically after each response	Query-error corrections
`AGENTIC`	The agent decides what is worth saving	Nuanced domain insights
`PROPOSE`	The agent proposes, a human approves before it persists	Anything that changes how numbers are computed

Audit what it learned

A data agent’s learnings change the numbers it reports, so they need to be inspectable. Read the Learned Knowledge store to see the corrections it captured, and the Decision Log for the reasoning behind a changed query shape.

lm = agent.learning_machine

# What the agent has learned about the warehouse:
lm.learned_knowledge_store.print(query="MRR")

# The audit trail of why a query shape changed:
lm.decision_log_store.print(agent_id=agent.id, limit=5)

Store	Why a data agent wants it
Learned Knowledge	Corrections that transfer across users
Decision Log	An audit trail of why a query shape changed

Next steps

Task	Guide
Feed it curated context too	Grounding in context
Gate writes behind approval	Safe data access

Welcome

Get Started

Features

Use Cases

Self-correcting agents

The loop

Choose how learning happens

Audit what it learned

Next steps

Developer Resources

​The loop

​Choose how learning happens

​Audit what it learned

​Next steps

​Developer Resources

The loop

Choose how learning happens

Audit what it learned

Next steps

Developer Resources