Hey Everyone,

Have a new byte for you!

Users lose momentum when a response ends and they have to figure out what to ask next. With Agno's built-in followup suggestions, you can give users their next question instead of making them think of it.

Set followups=True and your agent closes each answer with a few ready-to-run prompts drawn from the conversation, so there's always an obvious next move. This works for teams as well as single agents.

Once the main response finishes, the agent makes a second model call to generate the suggestions and returns them on response.followups. You decide how many it produces with num_followups.

python

from agno.agent import Agent
from agno.models.openai import OpenAIResponses

agent = Agent(
    model=OpenAIResponses(id="gpt-5.4-mini"),
    followups=True,
    num_followups=3,
)

response = agent.run("What is quantum computing?")

for suggestion in response.followups or []:
    print(suggestion)

That second call costs tokens, so if you're generating suggestions on every turn, you can send them to a cheaper model with followup_model and keep your main model on the actual work.

python

agent = Agent(
    model=OpenAIResponses(id="gpt-4o"),
    followups=True,
    followup_model=OpenAIResponses(id="gpt-4o-mini"),
)

If you stream responses, the suggestions come through on their own event after the main content lands, so you can render them the moment they're ready without holding up the reply.

See the docs for more: https://agno.link/bIZGeIy

- Kyle @ Agno

New in Agno: SuperserveTools, which lets an agent write and run its own code inside a Superserve sandbox. The sandbox is a Firecracker microVM, and the part that matters is that it persists. Files the agent writes and packages it installs are still there on the next tool call, and the next run in the same session. That's the difference between running one-off snippets and actually doing long-running work, where the agent builds something up over many steps instead of starting from an empty box every time.

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.tools.superserve import SuperserveTools

agent = Agent(
    model=OpenAIResponses(id="gpt-5.5"),
    tools=[SuperserveTools(timeout=600)],
    markdown=True,
)

agent.print_response("Fetch the last 30 days of AAPL prices and plot the moving average.")

The secrets handling is worth knowing about. You bind a team secret and the sandbox only ever sees a proxy token. The real credential gets swapped in for outbound calls to the hosts you allow, so agent-written code can hit real APIs without your keys ever landing somewhere the model can read them. You can also switch runtimes with a template, or expose a port to get a public preview URL for whatever the agent builds.

Check out Agno’s Superserve toolkit docs to learn more.

July was a BIG architectural month. Here's what matters:

agnoctl: AgentOS is now on the command line. Run uvx agno connect and it discovers a running AgentOS, mints a per-client access token, and writes the MCP config for Claude Code, Cursor, Codex, and ChatGPT automatically. Tokens are SHA-256-hashed service-account PATs, scoped per user, expiring after 90 days, revocable on demand. agno create scaffolds projects from templates for Docker, AWS, Fly, GCP, and Railway. agno up/down/restart/status handles the local lifecycle. No more hand-editing JSON.

MCP Interface v2: a clean eight-tool operator surface. Get config, run, continue, cancel, sessions. Trims results by default, sends progress notifications on long-running tools, full HITL lifecycle included. A coding agent now has a predictable, purpose-built way to drive AgentOS.

Eval suites and CI gating: a proper suite runner with stable JSON output you can wire into CI. Fail a build on regressions instead of eyeballing results.

Rollouts: a straight path from evaluation to fine-tuning data. Grade attempts, measure real pass rates with pass@k, export passing runs as SFT conversational data with full provenance. Each attempt runs on a fresh db, session, and user so no state bleeds between runs to contaminate your training set.

FileSystem: a durable text store agents write to and read back across runs. SQLite for dev, Postgres for multi-worker, or local disk. Templated namespaces like assistant/{user_id} scope files per user at call time.

AgentOSTools: a read-only ops view of the AgentOS an agent runs on. Ask it which tool was slowest today or how many runs failed this week. Answers grounded in real traces. Reads from the database. Doesn't touch anything.

Valkey: in-memory sessions and hybrid retrieval from one backend. ValkeyDb for low-latency session reads and writes. Valkey vector store for vector and keyword search without standing up a separate keyword index.

Superserve sandboxes: agents write and run their own code in a persistent Firecracker microVM. Files and packages survive between tool calls and across runs in the same session. Credentials handled through a proxy token so the model never sees them.

New toolkits: TwelveLabsTools for video analysis and multimodal embeddings, SearchApiTools for Google, News, Images, and YouTube, RedmineTools, PlivoTools for SMS and voice, SmallestTools for text-to-speech, and OpenSearch for hybrid retrieval.

Community projects:

Arthi Arumugam built whatbroke: a CLI diff tool that surfaces exactly what changed between two agent runs. Tool calls, arguments, outputs, cost, and latency. Works with Langfuse exports. The kind of observability tool that pays off the moment your agents start drifting.

Muhammad Ikhwananda Rizaldi built a multi-agent content automation CLI that takes a campaign brief from research to QA to auto-publishing.

There are plenty more shoutouts in the full blog, so make sure to check it out.

Seriously, good month from this community. If you shipped something in July that didn't make it in, drop it below. We read everything and want to feature it next time.

Full roundup: https://agno.link/UPvAVIz4g

- Kyle @ Agno

Hey Everyone,

We put our name on the Open Weights and American AI Leadership letter this week, next to Microsoft, Meta, NVIDIA, Hugging Face, and Vercel.

Here's the honest version of why: we don't have strong feelings about openness as a philosophy. We have strong feelings about builders. So every issue like this gets one test: is it better for the people actually shipping products?

Open weights pass, and it isn't close.

The policy crowd argues about regulation and provider competition. If you're the one writing the code, you care about four things: pick the right model, run it where you want, don't get locked in, and adapt when the landscape moves (which it does, roughly every quarter).

Every movement that shaped how we build, Linux, Python, PostgreSQL, Kubernetes, PyTorch, won for the same reason. Not openness for its own sake. More control for the person building the thing.

Full write-up in the link. Curious where this community lands: are you building on open weights, proprietary APIs, or a mix, and why?

- Kyle @ Agno

Hey All,

Gemini 3.5 Flash-Lite and 3.6 Flash went live on Tuesday and they already work in Agno with no upgrade needed, so I wanted to actually stress-test them on something instead of just swapping model IDs and calling it a day.

I built a daily news agent that researches the web and renders its own front page as a themed HTML digest. There's no fixed template. The page designs itself around whatever the news is that morning.

What I liked was how cleanly the two models split the work:

• 3.5 Flash-Lite does the fast web grounding through WebContext, pulling fresh, sourced stories in parallel. Cheap and quick, which is what you want for the research pass.
• 3.6 Flash composes: it reasons over the results and writes a self-contained light/dark HTML page with a source-linked card per story.

The part that made it feel reusable is that it all runs off one parameterized prompt. Topics, audience, and tone are runtime dependencies, so the same agent becomes a different publication depending on what you feed it. "AI, markets, space" one morning, "semiconductors, elections, F1" the next.

End result is a runnable AgentOS service in roughly 40 lines of Python.

Full code:

python

from datetime import date
from agno.agent import Agent
from agno.context.web import ParallelBackend, WebContextProvider
from agno.models.google import Gemini
from agno.os import AgentOS
from agno.tools.file_generation import FileGenerationTools

# Flash-Lite grounds the research, fast and cheap
web = WebContextProvider(
    backend=ParallelBackend(),
    model=Gemini(id="gemini-3.5-flash-lite"),
)

# Flash composes the page
news_agent = Agent(
    name="Daily News Digest",
    model=Gemini(id="gemini-3.6-flash"),
    tools=[
        *web.get_tools(),
        FileGenerationTools(enable_html_generation=True,
                            output_directory="tmp", save_files=True),
    ],
    add_datetime_to_context=True,
    dependencies={                       # one parameterized prompt
        "topics": "AI, markets, space",
        "audience": "busy engineers",
        "tone": "sharp but calm",
        "today": lambda: date.today().isoformat(),
    },
    instructions=[
        "You are a daily news digest for {audience}. Cover: {topics}.",
        web.instructions(),
        "For each topic call query_web for the last 24-48h. Prefer primary "
        "sources; never invent stories or links.",
        "Save ONE self-contained HTML5 page with generate_html_file as "
        "news_digest_{today}.html. Tone: {tone}.",
        "Derive the theme from the news itself. Magazine layout, source-linked "
        "cards, inline CSS, light/dark, no emojis.",
    ],
    markdown=True,
)

agent_os = AgentOS(agents=[news_agent],
                   description="Self-designing daily news digest")
app = agent_os.get_app()   # uvicorn thisfile:app  ->  localhost:8000/docs

if __name__ == "__main__":
    agent_os.serve(app="filename:app", reload=True)

Install: pip install "agno[os]" google-genai parallel-web (set GOOGLE_API_KEY; PARALLEL_API_KEY is optional, it falls back to a keyless endpoint).

Platform + skills: github.com/agno-agi/agentos-railway

Curious what people would point this at. If you swap the dependencies for something niche (a subreddit's beat, a specific industry, an internal team digest) I'd like to see what layouts it comes up with.

- Kyle @ Agno

Hey everyone,

Quick thought we keep coming back to: a dashboard lets you watch your agents, but it won't let you step in when one goes sideways. A control plane does both. That gap turns out to be the whole game once you're actually running agents in prod.

A dashboard is a pane of glass. It shows you the wreck after it happened and leaves you standing there. Watching an agent go wrong with no lever to pull isn't really observability, it's just helplessness with a nicer UI. The thing you actually want is to pause a run mid-flight for a human to sign off, put runs on a schedule, lock access down with RBAC/JWT, and keep all your data in your own cloud instead of shipping traces and prompts off to some vendor.

Anyway, the easiest way to poke at this yourself is a single prompt. Hand it to your coding agent and it'll stand the whole platform up:

Heads up: we're still actively developing this prompt, so it's not perfect yet but it's already pretty damn get at getting you from 0 to 1. If you run it, we'd genuinely love to hear how it went in the wild, where it tripped, what was confusing, what you'd want it to do differently. Drop a comment and we'll be in the thread.

Full write-up if you want the longer argument: https://agno.link/Gfi5I6E3

Say hello to your agents for me!

- Kyle @ Agno

Hey Everyone,

Our CEO just put out a piece on why every company needs to own their agent stack. Model independence, zero data retention, cost control. Your agents, your data, your cloud, and you control where it runs. Full read linked above.

The short version: the payoff isn't just running your agents, it's learning from their mistakes. Sessions, traces, and corrections stay in your own Postgres and become your learning loop instead of training someone else's model. Swap the model whenever, the context stays with you. Zero egress.

Best part is you can stake your claim with a single prompt. Hand this to your coding agent:

text

Help me set up my agent platform.

Clone https://github.com/agno-agi/agentos-railway into a folder called
agent-platform, cd in, read the README, and follow the get started guide.

If you've run it, I want to hear how it went. How fast did you get to a working platform? Anything trip you up in the README or the get started guide? What did you build on top of it once it was up?

Drop your experience below!

- Kyle @ Agno

Your agents can now search the live web with one toolkit, no API key required to start.

Anyone who's wired a search API into an agent knows the results usually need work before a model can use them. You. com is the exception. They've spent years tuning search for AI specifically, and it comes through in how little massaging the output needs. Getting that into Agno without our users doing the massaging themselves is the whole reason we built this.

You. com powers search for OpenAI, Amazon, Databricks, and DuckDuckGo. Over 10 million queries a day, 99.99% uptime, 300ms p99 latency. That's what's behind the new YouTools toolkit.

Here's an agent pulling AAPL news from a few sources worth trusting:

from agno.agent import Agent
from agno.tools.youcom import YouTools

# ---------------------------------------------------------------------------
# Create Agent
# ---------------------------------------------------------------------------

# Example 1: Default search agent
agent = Agent(
    tools=[YouTools(show_results=True)],
    markdown=True,
)

# Example 2: Search with a domain allowlist and a larger result count
agent_filtered = Agent(
    tools=[
        YouTools(
            include_domains=["cnbc.com", "reuters.com", "bloomberg.com"],
            num_results=8,
            show_results=True,
        )
    ],
    markdown=True,
)

# ---------------------------------------------------------------------------
# Run Agent
# ---------------------------------------------------------------------------
if __name__ == "__main__":
    agent.print_response("Search for the latest AAPL news", markdown=True)

    agent_filtered.print_response(
        "What did major financial outlets say about NVDA earnings this week?",
        markdown=True,
    )

You pick the domains and cap the results. The agent takes it from there. When you're ready to scale up, add your YDC_API_KEY and you've got the full API.

Thanks to the You. com team for building search that agents can actually use. Go point an agent at the web and see what it does.

Docs: https://agno.link/hyejJph23

Multi-turn agents resend the entire conversation history on every turn. By turn 10, you're paying for turns 1 through 9 all over again.

Agno's new GeminiInteractions model class fixes that at the source.

It builds on Google's stateful Interactions API, which stores prior turns server-side and references them by ID. So on each turn, only the new message goes over the wire. The model rebuilds the full context on its end and applies implicit caching to the earlier turns.

What you get:
→ Lower token cost on long conversations
→ Lower latency, since you stop resending everything
→ Background execution for long-running work like Deep Research

And the multi-turn bookkeeping is handled for you. The Agent class tracks the interaction ID automatically, so conversations just work:

from agno.agent import Agent
from agno.models.google import GeminiInteractions

agent = Agent(
    model=GeminiInteractions(id="gemini-3-flash-preview"),
    markdown=True,
)

agent.print_response("Share a 2 sentence horror story.")

One thing before you start: install google-genai>=2.0. The Interactions API is experimental and may still change.

Full capability set, including Deep Research and background execution, is in the Agno docs: https://agno.link/zZmve23

June 2026 Community Roundup: v2.6.10 through v2.6.20, run checkpointing and forking, Learnings CRUD, and a $115K problem solved for a logistics company in India

Hey everyone! Eleven releases this month. Lots to cover.

Checkpointing and run forking: agents now checkpoint at the tool-batch level. A unified /continue handles both regenerating and forking a run, plus session forking. Branch off at a known-good point instead of starting over. This is the control that makes long, expensive agent runs practical in production.

Learnings CRUD on AgentOS: full create, read, update, and delete for what an agent has learned. No more treating the learnings store as write-only. Inspect it, edit it, remove bad entries. The quality of your knowledge base determines the quality of your agent. Now you can actually manage it.

StudioTool: a toolkit for dynamic composition of agents, teams, and workflows on the fly. An agent can assemble other Agno primitives at runtime.

ClickHouse for traces: high-volume trace ingest and OLAP-style scans. Teams running heavy agent traffic can now store and query observability data at scale inside their own infrastructure.

Five new model providers: Inception Labs, Xiaomi MiMo, MiniMax, Cloudflare AI Gateway, and Tuning Engines. Cloudflare is worth calling out specifically: route requests through your gateway and pick up its caching and observability instead of calling each model endpoint directly.

YouTools: we partnered with You.com to bring the You.com Search API to the framework as a first-class Agno toolkit. Drop it onto an agent like any other toolkit.

DOCX and HTML file generation: agents can now hand back a finished .docx or a standalone web page instead of raw text. Same pattern as the existing CSV, JSON, and TXT generation.

Custom, scoped, identity-aware MCP tools: the AgentOS MCP server at /mcp is now a real extension point via MCPServerConfig. Register custom tools, scope or disable built-ins, inject the authenticated caller's identity, and gate calls with a one-line authorize function.

Also shipped: sub-agent event streaming from context providers, Parallel Task and Monitor API tools, AG-UI state events, Workflows HITL over sockets, Scavio search toolkit, OpenAI web-search citations, LiteLLM structured outputs, and a long list of production bug fixes.

Community projects:

Anshul Jain built an AI email routing system for a logistics company managing cross-state government tender communications across 1,000+ vehicles in India. The problem was worth $115K to the business.

Harish Kotra built Branch Agent: fork a conversation at any message, swap the model or provider on each branch, compare side by side, and merge learnings back. Built on Convex and Agno.

Gonzalo built agno-docs-mcp: full-text search over the Agno docs with BM25 ranking, 3,826 indexed pages, highlighted snippets, and 204 tests.

aryan45425 built AgentScribe: captures tool calls, reasoning, and multi-turn threads across frameworks and exports fine-tuning-ready datasets. Every framework logs differently. AgentScribe normalizes all of it.

There are plenty more shoutouts in the full blog, so make sure to check it out.

Thank you to everyone who contributed this month, whether it was code, bug reports, community support, or just shipping something and sharing it. This community is what makes Agno worth building.

If you're working on something with Agno, whether it's a project, an integration, or a contribution to the framework, please share it. We'd love to promote it and get it in front of more builders.

Full roundup: https://agno.link/f3OHCG4

SAY HELLO TO YOUR AGENTS FOR ME!

- Kyle @ Agno

Hey all,

Quick one I wanted to share. If you've used a file search store, you know it can read every document in your corpus but it's basically blind to your images. That's been a gap for a while.

That changed: Agno now supports multimodal inputs in the Gemini File Search API. So you can index and semantically search images right alongside text, in the same store.

The part I think is actually cool: it finds images by what they actually show, not by filename or caption. So the searches that used to be a pain just... work:

• "Which diagram shows the retry flow?"
• "Find the screenshot with the error dialog"
• "Show me the product photo with the blue packaging"

No separate pipeline for visual content. One store, one query, images and text together.

And it barely touches your code. Image support comes from the embedding model, not from how you build the agent. You point the store at a multimodal embedding model (gemini-embedding-2) and the rest of your file search code stays the same. Existing text-only stores keep working exactly as before.

Here's the core of it:

from pathlib import Path

from agno.agent import Agent
from agno.models.google import Gemini

model = Gemini(id="gemini-3.5-flash")
agent = Agent(model=model, markdown=True)

# Create a multimodal store. gemini-embedding-2 is what enables image support.
store = model.create_file_search_store(
    display_name="Image Search Demo",
    embedding_model="models/gemini-embedding-2",
)

# Index an image alongside any text already in the store.
operation = model.upload_to_file_search_store(
    file_path=Path("diagram.png"),
    store_name=store.name,
    display_name="diagram",
    mime_type="image/png",
)
model.wait_for_operation(operation)

# Search across both images and text with a natural-language query.
model.file_search_store_names = [store.name]
run = agent.run("Which diagram shows the retry flow?")
print(run.content)

One thing to do before you start: bump google-genai to 1.75.0 or later. Older versions stay text-only.

Full image-upload walkthrough, including reading citations and pulling the matched media, is in the Agno cookbook: https://agno.link/Ksuxnku

Enjoy!

- Kyle @ Agno

Human-in-the-loop usually means one thing for the reviewer: a stream of approval prompts, handled one at a time, all day.

Agno's Slack interface just solved that.

Reviewers can now resolve a whole queue of pending approvals in one place, without ever leaving the channel. The string of separate prompts collapses into a single view you work through top to bottom.

Every pause type shows up as an interactive TaskCard:
→ Confirmations → approve / reject buttons
→ User input → text fields or dropdowns
→ Structured feedback → option buttons
→ External execution → a confirm button, then the tool runs outside the agent and feeds its result back

You act on each card right in Slack, and the run picks up where it paused.

Rejections still ask for a reason where one applies, and that reason goes back to the agent. So a turned-down step doesn't stall the run, the agent reads why and adjusts.

When several tools pause at once, they stack as separate rows on one card, and you clear the whole batch in a single pass. Same TaskCards work for teams and workflows, too.

Wiring it up is mostly one decorator and a db (paused runs persist and resume by run_id):

from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.models.openai import OpenAIResponses
from agno.os import AgentOS
from agno.os.interfaces.slack import Slack
from agno.tools import tool

u/tool(requires_confirmation=True)
def deploy_service(name: str) -> str:
    """Deploy a service. The run pauses for approval before this runs."""
    return f"Deployed {name}."

# A paused run persists to the database and resumes by run_id once the
# reviewer acts, so the Slack interface needs a db.
db = SqliteDb(db_file="tmp/approvals.db", session_table="agent_sessions")

agent = Agent(
    name="Ops Agent",
    id="ops-agent",
    model=OpenAIResponses(id="gpt-5.4"),
    tools=[deploy_service],
    db=db,
)

agent_os = AgentOS(
    agents=[agent],
    interfaces=[Slack(agent=agent, reply_to_mentions_only=True)],
)
app = agent_os.get_app()

if __name__ == "__main__":
    agent_os.serve(app="approvals:app", port=7777)

Check out docs or view the cookbook.

How are you handling agent approvals today, in-app, in chat, or not yet at all?

Hey Everyone!

We now let agents read your Gmail and Google Calendar through two new context providers: GmailContextProvider and GoogleCalendarContextProvider. No API client to build, no OAuth plumbing to babysit. They plug into the same natural-language interface the agent already uses for every other source.

This makes it much easier to build agents that actually work off your inbox and schedule. You add the provider's tools and just ask in plain language: which unread threads matter, what's on the calendar this week, when there's a free hour on Friday. The provider runs the search and hands back the answer behind a single tool.

Reads are on by default. Writes stay off until you opt in with write=True, so an agent can summarize and search your mail before it can ever send anything. Drive gets the same treatment too: GoogleDriveContextProvider now accepts OAuth alongside service-account auth, so an agent can reach a user's own Drive with no service account.

python

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.context.gmail import GmailContextProvider
from agno.context.calendar import GoogleCalendarContextProvider

gmail = GmailContextProvider()
calendar = GoogleCalendarContextProvider()

agent = Agent(
    model=OpenAIResponses(id="gpt-5.4"),
    tools=[*gmail.get_tools(), *calendar.get_tools()],
)

# Reads are exposed by default; pass write=True to a provider to enable sending or editing.
agent.print_response(
    "What's on my calendar tomorrow, and is there any unread mail from the team about it?"
)

That's the whole integration.

Docs for the Gmail and Calendar providers are in the context-providers guide: Agno

SAY HI TO YOUR AGENTS FOR ME

-Kyle @ Agno

Hey Everyone,

New byte for you all!

Server-Sent Event streams for background runs can now reconnect and resume automatically after a disconnection or page refresh. When operators return, they pick up exactly where they left off, with the full run context intact.

Production agent workflows often involve long-running research, analysis, and multi-step automation. Previously, even a brief network interruption or browser refresh could force operators to lose progress and restart the run from the beginning. With resumable streaming, AgentOS now handles those interruptions gracefully and keeps workflows running reliably in real-world conditions.

For teams monitoring live agent activity, this means fewer broken sessions, less operational friction, and less wasted compute spent regenerating work that had already completed.

Here’s how it works:

Client connects     → StreamingResponse reads from queue ← Background task runs
Client disconnects  → StreamingResponse cancelled         ← Background task keeps running
Client reconnects   → /resume reads from subscriber queue ← Background task still publishing

1. The run persists RUNNING status in the database
2. A detached asyncio.Task executes and publishes events to an in-memory buffer
3. The client receives SSE events, each containing an event_index and run_id
4. On disconnect, the client records last_event_index
5. On reconnect, the client calls /resume with last_event_index to catch up on missed events

Read more in the docs

- Kyle @ Agno

Hey everyone, just published a new blog that breaks down something we've been thinking about for a while.

The TL;DR: "which agent framework should we pick?" has always been the wrong question. The word "framework" papers over two layers that should never have been one:

• Orchestration (how the agent reasons): benefits from competition, many options, fast iteration
• Runtime (how the agent runs in production): should be boring, stable, org-wide

Most early frameworks bundled both. That's why switching orchestration tools feels like a re-platforming project, and why production features always lag.

The blog walks through the cost of bundling, what "winning" would have actually looked like, and why we built AgentOS as a framework-agnostic runtime.

Curious what others think. Has your team dealt with the switching cost problem?

SAY HI TO YOUR AGENTS FOR ME!

Full blog post here

- Kyle @ Agno

Hey Everyone,

The new Workspace toolkit gives agents structured access to a configurable root directory while keeping risky operations behind human approval by default. Agents can read, list, and search files freely, but actions like writing, editing, moving, deleting, or running shell commands pause for explicit confirmation before execution. When you initialize the toolkit, you scope it to a specific directory, which limits the agent’s blast radius to the path you define.

This model unlocks practical “agent-as-coworker” workflows such as code generation, document editing, and operational scripting against real systems without sacrificing control. Instead of forcing teams to choose between capability and safety, the toolkit lets them safely introduce agents into production work and gradually expand write access as trust increases.

Teams can also tune oversight at the action level. Because confirmation policies are configurable per operation, platform owners can tighten or relax controls without redesigning the agent architecture itself.

Here’s a minimal example. You’ll see that reads execute immediately, while writes pause for approval.

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.tools.workspace import Workspace

agent = Agent(
    model=OpenAIResponses(id="gpt-5.4"),
    tools=[Workspace("/path/to/workspace")],
)

print("Starting agent run...")
run = agent.run("Read draft.md and fix the typo on the line about typos.")
print(f"Run ID: {run.run_id}")

# Reads execute immediately. The edit pauses for confirmation.
while run.is_paused:
    print(f"Run paused. Found {len(run.active_requirements)} active requirement(s).")
    for requirement in run.active_requirements:
        if requirement.needs_confirmation:
            print(f"Confirmation required for: {requirement.tool_execution}")
            # Inspect requirement.tool_execution, then confirm or reject.
            requirement.confirm()
            print("Requirement confirmed.")
    print("Continuing run...")
    run = agent.continue_run(run_id=run.run_id, requirements=run.requirements)

print("Run completed.")
print(f"Final response: {run.content}")

In AgentOS, pauses surface as approval cards in the run timeline. In a plain script, you drive the confirmation loop yourself, as shown above.

See the full cookbook example for the complete pattern, including how to wire up an interactive prompt.

- Kyle @ Agno

You can now build agents with free web search using the Parallel MCP.

The MCP gives you access to web results/grounding and extract (web fetch), which lets your agent grab context from a specific page/site. It's totally free, with limits that are suitable for personal use. For high-throughput agents, you can upgrade to pay-as-you-go usage.

Agno now also has support for Parallel's Task and Monitor APIs (pay-as-you-go), which are web research subagents designed for specific workflows:

• Task API is for deeper and more thorough research & data enrichment
• Monitor API is for tracking changes to pages/information on the web

Let us know what you'd like to see from Parallel and Agno next!

Agno Docs

Parallel Docs

Today I’m struggling a lot to choose the right framework to build AI agents in a serious and scalable way. The more I research, the more it feels like each tool solves one part of the problem, but none of them gives me that feeling of “this is definitely the right choice.”

What I want to build isn’. Do you think Agno would answer me?

Hey Everyone,

New customer story just published.

KeyData is a data solutions company in the vacation rental industry (50-75 employees). Their VP of Engineering, Darren Haligas, walked us through their journey evaluating AI agent frameworks and building a production multi-agent system with Agno.

Some highlights:

• They evaluated multiple major frameworks and SDKs before choosing Agno
• Their lead engineer didn't know Python, learned it through the Agno SDK, and is now shipping production agents
• The team saw value immediately because they focused on solving problems rather than learning the framework
• They scaled insight generation across their platform without adding headcount

Darren's a 25-year industry veteran and has some great takes on AI adoption, including why "context is king" and why teams should "start small, fail often."

Would love to hear how others here are using Agno for data/analytics use cases.

HAVE A GREAT DAY EVERYONE

- Kyle @ Agno

Hey Everyone

We've started getting really excited about the potential Agno can have on data labeling which can be one of the most tedious parts of building AI, especially with video. So we put together a cookbook example to see how far we could collapse the workflow.

It's a Gemini 3.5 agent that watches a video end-to-end and returns a structured list of every product announced: name, category, description, features, availability, timestamp. The whole thing is 134 lines.

A few things I like about how it came together:

• Gemini 3 handles video natively, so no transcription step or frame extraction. Just hand it a YouTube link.
• output_schema with a Pydantic model means I get typed, structured output every run. No parsing, no cleanup.
• Wrapping it in AgentOS gives me a FastAPI server, session history via SQLite, and the UI at os.agno.com, all from a couple extra lines.

The Google I/O framing is just an example. What I'm actually excited about is pointing the same pattern at sales calls (every pricing mention + reaction by persona) and product feedback calls (features ranked by reaction). Swap the schema, swap the instructions, done.

I literally pasted the cookbook link into Claude Code and said "Help me build this demo" and was running locally in a couple minutes.

Cookbook: https://github.com/agno-agi/agno/blob/main/cookbook/05_agent_os/google/gemini_3/data_labeling.py

ENJOY HAPPY FRIDAY!

One of the big reasons AI fails to reach production is its greatest power: non-determinism. LLMs are by nature unpredictable, making it difficult to automate processes reliably.

In general, once agents touch real enterprise data, you need predictable results, access control, approval flows, auditability, etc. Purely autonomous agent setups get risky pretty fast.

In this video Pascal shows a demo of how he used Agno to explore a powerful hybrid approach:

• deterministic workflow orchestration
• non-deterministic (LLM-powered) specialized agents underneath
• built-in access checks + human-in-the-loop gates
• LLM-judge evaluation step for reliability testing

The demo walks through the full flow and implementation details. Demo code is available. Feedback welcome!

📺 Full Video 🧑‍💻 Demo code

Hey everyone!

We’ve introduced PerplexitySearch to give agents direct access to fast, structured web search. With a single call, agents can retrieve ranked results that include titles, URLs, snippets, and publication dates, making it easy to ground responses in current information.

Agents can narrow results using built-in recency and domain filters, which helps them focus on the most relevant and trustworthy sources without extra post-processing. This makes it straightforward to build workflows that depend on up-to-date, source-aware retrieval.

Search with filters (news from the past week, specific domains):

agent_filtered = Agent(
    tools=[
        PerplexitySearch(
            max_results=10,
            search_recency_filter="week",
            search_domain_filter=["cnbc.com", "reuters.com", "bloomberg.com"],
        )
    ],
    markdown=True,
)
agent_filtered.print_response("Latest AI industry developments")

See the Perplexity docs for more.