Introduction

Build, run, and manage multi-agent systems at scale.

Agno is the programming language for agentic software.

Agentic software operates under a different contract than traditional software. Execution is dynamic. Decisions are contextual. Trust must be engineered. Agno provides the primitives, execution engine, and production runtime to handle that natively.

Layer	What it does
SDK	The primitives: agents, teams, workflows, memory, knowledge, tools, guardrails, approval flows.
Engine	The agent loop: model calls, tool execution, context management, runtime checks.
AgentOS	The production runtime: streaming APIs, authentication, request isolation, approval enforcement, background execution, and a control plane to monitor and manage everything.

Why Agno?

Agentic software introduces three fundamental shifts.

A new interaction model. Traditional software receives a request and returns a response. Agents stream reasoning, tool calls, and results in real time. They can pause mid-execution, wait for input or approval, and resume days later. Agno treats streaming and long-running execution as first-class behavior.

A new governance model. Traditional systems execute predefined decision logic written in advance. Agents choose actions dynamically. Some actions are low risk. Some require user approval. Some require administrative authority. Agno lets you express who decides what as part of the agent definition, with approval workflows, human-in-the-loop, and audit logs built in.

A new trust model. Traditional systems are designed to be predictable. Every execution path is defined in advance. Agents introduce probabilistic reasoning into the execution path. Agno introduces trust as part of the system by running guardrails during execution, evaluations in the background, and treating traces and audit logs as first-class citizens.

What You Can Build

This is Gcode: a coding agent that writes, reviews, and iterates on code. It remembers project conventions, learns from its mistakes, and gets sharper the more you use it.

from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.learn import LearnedKnowledgeConfig, LearningMachine, LearningMode
from agno.models.openai import OpenAIResponses
from agno.tools.coding import CodingTools
from agno.tools.reasoning import ReasoningTools

gcode = Agent(
    name="Gcode",
    model=OpenAIResponses(id="gpt-5.2"),
    db=SqliteDb(db_file="agno.db"),
    instructions=instructions,

    # Knowledge: searchable long-term memory the agent can query
    knowledge=gcode_knowledge,
    search_knowledge=True,

    # Learning: the agent extracts and stores its own learnings over time
    learning=LearningMachine(
        knowledge=gcode_learnings,
        learned_knowledge=LearnedKnowledgeConfig(mode=LearningMode.AGENTIC),
    ),

    # Tools: sandboxed file ops + chain-of-thought reasoning
    tools=[CodingTools(base_dir=workspace, all=True), ReasoningTools()],

    # Memory: learn user preferences
    enable_agentic_memory=True,

    # Context: add the last 10 runs to context
    add_history_to_context=True,
    num_history_runs=10,
    markdown=True,
)

No external memory service. No vector DB to configure separately. Knowledge, learning, memory, and tools are part of the agent definition, because in Agno, they’re primitives, not integrations.

Get Started

• Start with the Quickstart
• Explore the SDK
• Learn about AgentOS
• Deploy to your cloud of choice