Shop Up Front, Factory Out Back

Shop up front, factory out back: that’s the old merchant’s playbook. Make the goods in the workshop behind, sell them over the counter in front, the whole operation under one roof.

Building AI agents works the same way these days. Writing the agent isn’t the end of it. People have to be able to use it, it has to plug into your product, it has to show up in chat apps, and you have to be able to inspect it, manage it and clean up its messes. Build all that from scratch and you’re looking at a few months, minimum. Some folks say that with Agno, you can be live in a day.

Cartoon illustration: two joined buildings on a street. On the left is a brick factory with a sawtooth roof and a smoking chimney, its sign reading “Factory · Agno SDK”; inside, a grey robot in a yellow hard hat holds a wrench, and a conveyor belt carries three freshly built little robots in blue, orange and teal. On the right is a shopfront with a red wall and yellow-tiled eaves, its black sign in gold letters reading “Shop · AgentOS”. Its three windows are labeled “API”, “MCP” and “Slack”, and in each sits a little robot handing something out: a sheet with curly braces, a sheet marked MCP, a chat bubble with a hash sign. On the roof is a small control room labeled “Console”, its screen showing a rising line, with a price tag hanging below that reads “$150/mo”. Out on the street to the left, lzbob in a black baseball cap looks up, his speech bubble saying “Free to open, pay to watch?” — The factory builds the agents, and the shop sells them out of three windows. That little control room on the roof? Rent’s due monthly.

So what is it

Agno used to be called Phidata. It changed its name, and the old repo address now forwards straight to the new place. It’s written in Python, Apache 2.0 licensed, with 43,000 stars on GitHub (43,089 when I looked), over 6,200 forks and 100-plus contributors, and it shipped v3.1.12 at the end of October. The docs are pretty thorough.

The README calls it a “self-managing agent platform,” in three parts: build, run, put to work.

Out back: building agents

The factory out back is Agno’s SDK. The basic skills:

Agents, teams, workflows: a single agent can use tools; put a few together as a team and they divvy up the work and talk it over; workflows handle order, conditions, loops and running things in parallel.
Memory and knowledge: remembers users across sessions and looks up answers in your own material.
Tools: the docs list over a hundred ready-made toolkits alone, and it can hook into databases and MCP servers.
Models: the docs list fifty-odd model providers, DeepSeek, Alibaba’s Tongyi, MiniMax, Xiaomi MiMo and SiliconFlow among them; running locally on Ollama, LM Studio or vLLM works too.

And it’s not just its own SDK. Agents built with the Claude and Codex agent SDKs can go on its shelves too.

The official tutorial has a “personal assistant” example. Trimmed down, it looks roughly like this, saved as personal_agent.py:

from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.os import AgentOS

db = SqliteDb(db_file="agent.db")

agent = Agent(
    name="Pip",
    model="openai:gpt-5.6",
    db=db,
    add_history_to_context=True,
)

agent_os = AgentOS(agents=[agent], db=db)
app = agent_os.get_app()

if __name__ == "__main__":
    agent_os.serve(app="personal_agent:app")

A dozen-odd lines of code, and the agent is a running service.

Up front: AgentOS opens for business

AgentOS is the server that runs your agents, built on FastAPI. Put an agent in, and it becomes a service that can run for the long haul:

One kitchen, several windows: your own product comes in through the REST API; Claude and ChatGPT use it over MCP; chat apps like Slack, Telegram, WhatsApp and Discord all have ready-made connectors.
House rules: login and authentication, role-based permissions, each user’s data kept separate; anything important stops and waits for a human to sign off; jobs can run on a schedule; if a background task dies, it picks up where it left off after a restart, and you can replay it.
Books you can audit: every run can be traced, so you can see which tools it called and where it went wrong.
Opens on your own cloud: there are ready-made templates for Docker, AWS, GCP, Azure, Railway and the like, and the data stays in your own hands.

Part three: agents that manage themselves

The new version also adds a Company OS: you give agents job responsibilities, break the work into projects and tasks, and set up routines. The gist of the README: humans set the direction and look at the results, and the agents do the work themselves.

That’s a whole lot of bosses’ dream, word for word.

Getting started has a new twist, too. It says it’s “built for coding agents”: the official instructions have you hand a paragraph to a coding assistant like Claude Code, and let it clone the template and set everything up step by step, following the instructions inside. Once installed, it comes with a routine check that runs every day, going through your code and through new Agno releases, then suggesting improvements.

Even installing the framework is a job it’s handed off to AI.

Doing the math

Free: the SDK and AgentOS are both open source and run on your own cloud, free at any scale; the outward-facing REST, MCP and Slack services cost nothing either. You can use the console too, but it only connects to an AgentOS running locally.
Pro, $150 a month: the console can connect to your live production deployment; includes one connection, three seats and role-based permissions. Each extra seat is $30, each extra connection $95, SAML single sign-on $300.
Enterprise: price on request.

Fair warning

Python only: there’s no JS/TS SDK, so if your frontend wants in, it goes through the API.
LangChain is still the bigger name: LangChain has 149,000 stars to Agno’s 43,000, and the third-party tutorials and off-the-shelf parts are mostly on that side of the street.
The console costs money: once you’re live, if you want its console watching production, you need Pro.
Telemetry is on by default: each agent sends a telemetry ping telling them which model provider you use. Your prompts and conversations aren’t sent. To turn it off, set AGNO_TELEMETRY=false.
“Live in a day”: you can put the skeleton up in a day, but whether the agent is any good comes down to the work you give it, the material you feed it, and round after round of tuning. That doesn’t happen in a day.

One last thing

The factory’s free, the shop’s free, and the AI even handles the fit-out. Only the little control room on the roof, the one keeping an eye on business, pays rent by the month.

An old shopkeeper would put it like this: opening the store is free. Minding the store is what costs you.