Ashpreet Bedi

All articles

Build an agent platform without writing a single line of code

The future is here, just not evenly distributed.

Today I'll show you how to build your own agent platform without writing a single line of code.

I know this sounds crazy, so I'll share videos along the way and encourage you to build along. All you need is a coding agent, docker, and an OpenAI API key.

But first, what is an agent platform and why is every company building one?

What is an Agent Platform?

An agent platform is the system that runs your agents. It handles agent execution (i.e. running the agents), manages sessions and context, enforces security policies, logs traces, and connects your agents to frontends via API, MCP, or chat interfaces like Slack.

An agent platform provides a shared foundation that you can build your company's AI applications on. Without a shared platform, every agent becomes its own silo, each needing its own deployment, authentication, database, observability, and integrations.

Most companies build their own agent platform to own the learning loop. To retain full control over the agent's behavior, data and context. Which paves the way for reflective self improvement.

Let's Get Started

The first thing we're going to do is set up our agent platform. I'm going to show how to do that with one prompt. I know this sounds mad, so here's a video of it in action.

Want to follow along? Go to os.agno.com, get the prompt for your cloud provider (I'm using Railway) and hand it to your favorite coding agent (I'm using Claude Code).

For a one-shot experience like the video, make sure you have docker installed and running, and export your OpenAI API key using export OPENAI_API_KEY=<your-api-key>

Under the hood, the coding agent first clones an agent-platform template (built by yours truly) and then runs the /setup-platform skill. The /setup-platform skill teaches the coding agent how to set up your environment, run the platform on Docker, verify its running, and get you connected to the AgentOS UI. It ends by running the /create-agent skill, which I used to create an agent called Radar.

Ten minutes from a fresh machine to a running platform.

Skills for days

When I say "build without writing a single line of code", I mean you don't write any code, the coding agent does. But how do we do that reliably? A unified platform + skills.

The agent platform we created above is structured so that agent code, logs, traces, evals and the live service all live in one place, accessible to the coding agent doing the implementation. A complete paradigm shift because you're no longer stitching different services together.

Because the coding agent can make changes to the code, and probe the live running system, it's able to take full control of the agent development lifecycle. It can create agents (using /create-agent), reflect on usage and improve them (using /improve-agent), fix bugs add new features (using /extend-agent), write and run evals (using /create-evals and /eval-and-improve), keep the codebase in sync (using /review-and-improve), and even deploy the platform to production.

All of this is possible because a) the gnarly wiring is handled by Agno, so the coding agent is just putting things together, and b) all information the coding agent needs is available using Agno's MCP server. So the coding agent is simply assembling a puzzle, with access to the manual via MCP.

I won't go into the details for each skill, but I will showcase the /improve-agent skill. Which covers the most important part of your agent platform: the learning loop.

/improve-agent takes an agent and runs N simulations (called probes) to evaluate the agent's performance. It derives these probes from the agent's own instructions and from its real usage (stored in the database). It then runs the probes against the live container, judges the responses, and improves the agent until they pass. It's rare for me to publish an agent without running this skill first.

Let's see it in action. cd into your agent platform and restart your coding agent so it picks up the new skills. Then run /improve-agent to improve your agent, my run took about 29 minutes so read the rest of the article before running this. It really does work through the edge cases.

Give your agent platform a UI

Every step so far has been in a terminal, next let's give our agent platform a UI. Head to os.agno.com and connect your platform.

Here's the part I like. The AgentOS UI connects directly from your browser to your runtime. The flow of data is entirely between your browser and the running API. Sessions, traces and memory stay in your database and you retain full control and ownership of your data and context.

Connect your agents to your frontends

You're not building an agent platform to replace Claude or ChatGPT. You're building an agent platform to power your product and operations with custom agents you own and control. Meaning building agents is only part of the puzzle, you also need to connect them to:

  1. Your product. Use the REST API to call your agents from your product.
  2. Your AI apps. Connect your agents to Claude and ChatGPT using the MCP server.
  3. Your chat apps. Expose agents in Slack, Discord and Telegram using Agno Interfaces.

Luckily, your agent platform is already set up to do all three.

First, go live using the /deploy-platform skill

To connect your platform to AI apps like Claude and ChatGPT, or chat apps like Slack, Discord and Telegram, you need to deploy your platform so it is reachable from the internet.

So before we wire up the AI apps and chat apps, let's take our platform live. Run the /deploy-platform skill, which will deploy the platform to the cloud template you selected during setup (I'm using Railway).

Connect your agents to your AI apps using the MCP server

This is the part I'm most excited about. A large number of the custom agents and workflows you'll build will be used through AI frontends like Claude, ChatGPT, Claude Code and Codex. If you've ever heard anyone moan about shared context between AI apps, this is the solution.

And its remarkably simple to do so. Your agent platform (built on AgentOS) exposes every agent, team, and workflow using an MCP server, so Claude and ChatGPT can connect to your AgentOS and run your agents.

Let's test it out by connecting Chief (the company mascot) to Claude.

In Claude, go to Settings → Connectors → Add custom connector and paste your platform's MCP URL: https://<your-railway-domain>/mcp. Leave the client ID and secret fields empty. Connect and it'll take you to a consent page asking for your connect secret: that's the MCP_CONNECT_SECRET the /deploy-platform skill generated and added to .env.production (it prints it in the deploy summary, copy it). Once you confirm, Claude can interact with your AgentOS using MCP.

First, tell Claude that whenever you ask for "Chief", you want to run the chief agent on AgentOS (it'll add it to its memory).

Whenever I ask for "Chief", you should run the chief agent on AgentOS.

Then tell Claude to interact with Chief.

Tell chief the surfer leo zapato from garaje was 🔥.

Connect chief to slack

Next, let's make Chief available in Slack. You can connect your agents to any chat app using Agno Interfaces. Slack is the most popular, and comes pre-wired in the platform template.

Create a Slack app for your workspace (the Agno docs have a step-by-step guide), point its Event Subscriptions URL at https://<your-railway-domain>/slack/events, and grab two values: the bot token and the signing secret. Set SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET in .env.production, run ./scripts/railway/env-sync.sh (or tell your coding agent to run it), and chief should be available over slack.

Use your agents from your product using the REST API

This is the last one, and the easy one. Your agent platform comes with a complete API with 80+ endpoints. Run agents, stream responses, list sessions, manage knowledge. Use this API to build agentic products on top of your platform.

Go localhost:8000/docs for the full list of endpoints. Everything the AgentOS UI does, your product can do too. The AgentOS UI uses the exact same API.

Wrapping up

Today we built a unified agent platform using nothing but a prompt, took it live, and connected it to Claude, ChatGPT, and Slack. End to end, this guide would probably take you ~30-40 minutes, which is pretty awesome! Now the fun part, build more agents, improve them, and connect them to your product, use them in your AI apps or chat apps. Here is the full set of skills, for reference:

  • /setup-platform takes you from a fresh clone to a running platform
  • /create-agent creates a new agent and tests it
  • /extend-agent makes changes to existing agents, add features, fix bugs, etc.
  • /improve-agent recursively improves the agent against its own instructions and usage patterns
  • /create-evals creates new evals for the agent, lock in good behavior via tests
  • /eval-and-improve runs the evals and improves the agent if they fail
  • /review-and-improve keeps the full codebase in sync, docs, code, and config coherent.
  • /deploy-platform deploys the platform to production

Total lines of code written by me: zero.

The future is here. Go to os.agno.com and see for yourself. Links for reference: