AI Agents with Agno — Build & Deploy Guide

Agno is an open-source SDK and runtime for building your own agent platform. When combined with Neosantara as the native model provider, you get a production-ready agent platform with access to top-tier models through Indonesia's fastest AI gateway.

In this guide, we'll explore Agno's architecture, build agents step by step, and show how Neosantara makes each part better — from tool calling and knowledge retrieval to multi-agent teams and production deployment.

The AI agents market is projected to reach $10.9 billion in 2026, making this the ideal time to invest in a production-ready agent stack (MarketsandMarkets, "AI Agents Market Report," 2026).

#What is Agno?

Agno provides three layers:

1. Agno SDK — Build agents, multi-agent teams, and step-based workflows
2. AgentOS Runtime — Run agents as a service with multi-user isolation, tracing, scheduling, RBAC, and audit logs
3. Control Plane — Manage everything from a unified UI

The core building block is the Agent: a stateful loop around a language model that can use tools, maintain memory, search knowledge bases, and stream responses.

#Why Agno + Neosantara?

Neosantara is available as a native Agno model provider through agno.models.neosantara.Neosantara. This means:

• No custom wiring — Use Neosantara models inside Agno agents without building OpenAI-compatible adapters
• Model selection — Choose from Neosantara's catalog: Claude Opus 4.6, Gemini 3 Flash, Kimi K2, Archipelago 70B, and more
• Low latency — Neosantara's local gateway keeps agent response times fast
• Rupiah billing — Pay in IDR with transparent pricing
• Full feature access — Tools, streaming, knowledge, teams, and workflows all work out of the box

#How Do You Get Started with Agno?

#Installation

pip install -U agno

#Authentication

Set your Neosantara API key as an environment variable:

export NEOSANTARA_API_KEY="nsk_..."

The native provider uses https://api.neosantara.xyz/v1 by default. You can also pass api_key or base_url directly to Neosantara(...) when you need explicit runtime configuration.

For routing requests across multiple providers, see our LiteLLM integration guide.

#Your First Agent

from agno.agent import Agent
from agno.models.neosantara import Neosantara

agent = Agent(
    model=Neosantara(id="claude-opus-4-6"),
    markdown=True,
)

agent.print_response("Explain what an AI gateway does in two sentences.")

That's it. Every Agno feature — tools, knowledge, streaming, teams — builds on this foundation.

Ready to try it yourself? Get your free Neosantara API key and start building in under 5 minutes — no credit card required, Rp 10,000 free credit included.

#What Core Features Does Agno Offer?

#1. Agents with Tools

Tools let agents interact with external systems. Agno comes with 120+ pre-built toolkits — or you can write your own.

from agno.agent import Agent
from agno.models.neosantara import Neosantara
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    model=Neosantara(id="claude-opus-4-6"),
    tools=[DuckDuckGoTools()],
    instructions=[
        "Search only when the answer needs current information.",
        "Cite the most relevant source names.",
    ],
    markdown=True,
)

agent.print_response(
    "What changed in the Indonesian AI ecosystem recently?",
    stream=True,
)

Custom tools are simple Python functions. Agno automatically converts them into model-compatible tool definitions:

import random
from agno.agent import Agent
from agno.models.neosantara import Neosantara
from agno.tools import tool

def get_weather(city: str) -> str:
    """Get the weather for the given city.

    Args:
        city: The city to get the weather for.
    """
    conditions = ["sunny", "cloudy", "rainy", "windy"]
    return f"The weather in {city} is {random.choice(conditions)}."

agent = Agent(
    model=Neosantara(id="claude-opus-4-6"),
    tools=[get_weather],
    markdown=True,
)

agent.print_response("What is the weather in Jakarta?")

#2. Streaming

For dashboards, chat interfaces, and terminal assistants, enable streaming:

agent.print_response(
    "Create a concise incident-response checklist for an API outage.",
    stream=True,
)

For production, use agent.run() with streaming:

from typing import Iterator
from agno.agent import RunOutputEvent, RunEvent

stream: Iterator[RunOutputEvent] = agent.run(
    "Analyze this server log for errors.",
    stream=True,
)
for chunk in stream:
    if chunk.event == RunEvent.run_content:
        print(chunk.content, end="")

#3. Knowledge & RAG

Knowledge gives agents access to documents, databases, and domain expertise. This turns them from static systems into systems that learn.

from agno.agent import Agent
from agno.knowledge import Knowledge
from agno.vectordb.chroma import ChromaDb
from agno.models.neosantara import Neosantara

knowledge = Knowledge(
    vector_db=ChromaDb(
        collection="company-docs",
        path="tmp/chromadb",
    ),
)

knowledge.insert(url="https://docs.neosantara.xyz/en/agno")

agent = Agent(
    model=Neosantara(id="gemini-3-flash"),
    knowledge=knowledge,
    search_knowledge=True,
)

agent.print_response("How do I set up Neosantara in Agno?")

Agno supports 20+ vector databases — from local (LanceDB, ChromaDB) to managed (Pinecone, Weaviate, Qdrant).

Agentic RAG is the default mode: the agent decides when to search its knowledge base. You can also use Traditional RAG for always-inject contexts.

#4. Multi-Agent Teams

Single agents hit limits fast. Teams let you distribute work across specialized agents.

from agno.team import Team
from agno.agent import Agent
from agno.models.neosantara import Neosantara

researcher = Agent(
    name="Researcher",
    model=Neosantara(id="claude-opus-4-6"),
    instructions="Research the topic thoroughly and provide findings.",
    tools=[DuckDuckGoTools()],
)

writer = Agent(
    name="Writer",
    model=Neosantara(id="gemini-3-flash"),
    instructions="Write a clear article based on the research.",
)

team = Team(
    name="Content Team",
    mode="coordinate",
    members=[researcher, writer],
    model=Neosantara(id="claude-opus-4-6"),
)

team.print_response("Write about the latest AI trends in Indonesia.")

Team modes control how collaboration works:

Teams can also be nested — a team can contain other teams — giving you a powerful hierarchy for complex applications.

#5. Workflows

Workflows orchestrate agents, teams, and functions through defined steps. Unlike Teams (which collaborate dynamically), Workflows follow a predictable sequence.

from agno.workflow import Workflow
from agno.agent import Agent
from agno.models.neosantara import Neosantara

research_agent = Agent(
    name="Researcher",
    model=Neosantara(id="claude-opus-4-6"),
    tools=[DuckDuckGoTools()],
)

writing_agent = Agent(
    name="Writer",
    model=Neosantara(id="gemini-3-flash"),
)

content_flow = Workflow(
    name="Content Pipeline",
    steps=[research_agent, writing_agent],
)

content_flow.print_response("Research and write about AI regulation.")

Steps can run sequentially, in parallel, in loops, or conditionally — giving you full control over execution flow.

#6. Memory & Sessions

Agno agents maintain persistent state across conversations. This is critical for building assistants that remember context.

from agno.agent import Agent
from agno.models.neosantara import Neosantara
from agno.db.sqlite import SqliteDb

agent = Agent(
    model=Neosantara(id="claude-opus-4-6"),
    session_state={"preferred_language": "Python"},
    db=SqliteDb(db_file="tmp/agents.db"),
    add_history_to_messages=True,
)

agent.print_response("What language do I prefer?")

The session state persists across runs, enabling long-running conversations with full context.

#7. AgentOS — Production Runtime

When your agent is ready for production, AgentOS turns it into a managed API:

• Multi-user isolation — Every session runs in its own sandbox
• Tracing — Full observability into agent decisions
• Scheduling — Run agents on cron-like schedules
• RBAC — Role-based access control for team members
• Audit logs — Complete trace of all agent activity

Your data stays in your infrastructure. Sessions, memory, and traces are stored in your database.

#Which Model Should You Use with Agno?

Choose Neosantara models based on the agent's task:

#When Should You Use Agno?

#Why Build AI Agents with Agno and Neosantara?

Agno gives you a complete platform for building AI agents — from single-agent prototypes to multi-agent teams running in production. With Neosantara as the native model provider, you get top-tier models through a local gateway with Rupiah pricing, no custom wiring needed.

The combination is powerful: Agno's agent runtime + Neosantara's model catalog + Indonesia's fastest AI gateway. Start small with a basic agent, add tools and knowledge as your needs grow, and scale to teams and workflows when you're ready — all without changing your model provider.

#Frequently Asked Questions

#How much does Neosantara cost for Agno development?

Neosantara offers a free tier with Rp 10,000 credit to start — enough to build and test your first agents. After that, pricing is per-token with Rupiah billing and no hidden fees. You only pay for what you use across any model in the catalog. See the Neosantara pricing page for current rates.

#Can I use Agno with other providers alongside Neosantara?

Yes. Agno is model-agnostic — you can mix Neosantara, OpenAI, Anthropic, and local models within the same team or workflow. Neosantara's value is simplifying multi-provider access through a single API key and local gateway. For more on multi-provider routing, see our LiteLLM integration guide.

#Is Agno ready for production workloads?

Yes. Agno's AgentOS provides multi-user isolation, tracing, scheduling, RBAC, and audit logs — everything needed for production deployment. Data stays in your infrastructure; sessions, memory, and traces are stored in your own database. Combined with Neosantara's production-grade API, the stack is built for real workloads.

#What's the fastest way to get started?

Install Agno (pip install -U agno), set your Neosantara API key, and run the "Your First Agent" example above. Total time: under 5 minutes. For a deeper walkthrough, see the Neosantara Agno documentation.

#Source References

1. MarketsandMarkets, "AI Agents Market Report," 2026. Retrieved June 20, 2026 from https://www.marketsandmarkets.com/Market-Reports/ai-agents-market-15761548.html
2. Agno Documentation — "Tools Overview." Retrieved June 20, 2026 from https://docs.agno.com/tools
3. Agno Documentation — "Knowledge Base Overview." Retrieved June 20, 2026 from https://docs.agno.com/knowledge/overview
4. Neosantara Documentation — "Agno Integration Reference." Retrieved June 20, 2026 from https://docs.neosantara.xyz/en/agno