The Beginning

This is ayo. A different way to think about AI agents.

We've been building AI tools for a while now. The pattern is always the same: take a model, wrap it in a chat interface or an IDE plugin, add some context retrieval, and call it an "agent." It works, kind of. But it doesn't feel like the right abstraction.

ayo starts from a different premise: what if agents were more like Unix processes than chat sessions? What if you could compose them, pipe data between them, run them in parallel, and orchestrate complex workflows—all from the command line?

What's in v0.1.0

Agents as Directories

An agent in ayo is just a directory. A config.json for settings, a system.md for personality, and optionally a skills/ folder for capabilities. That's it.

This means you can version them with git, copy them to share with others, diff them to see what changed. All the tools you already know work on agents.

                ~/.config/ayo/agents/@researcher/
├── config.json
├── system.md
└── skills/
    ├── web-search
    └── pdf-reader
            

Skills

Skills are what agents can do. They're composable, version-controlled, and shareable. An agent with the web-search skill can find information online. Add summarizer and it can condense what it finds.

ayo agent add-skill @researcher web-search summarizer

Squads

Sometimes one agent isn't enough. Squads let you run multiple agents together, each in their own isolated sandbox but sharing a ticket system for coordination.

Think of it like pair programming, but with three reviewers, a researcher, and someone keeping notes—all working simultaneously.

ayo squad new content-team @writer @editor @factchecker

Flows

Flows are YAML-defined workflows. You declare the steps, dependencies, and error handling. ayo figures out what can run in parallel and handles the orchestration.

                name: weekly-digest
steps:
  - name: gather
    agent: "@researcher"
    prompt: "Find this week's highlights"
    
  - name: write
    agent: "@writer"
    depends_on: [gather]
    prompt: "Write the digest"
    
  - name: review
    agent: "@editor"
    depends_on: [write]
    prompt: "Polish and finalize"
            

Memory

Agents can remember things across sessions. Personal preferences, project context, learned patterns—stored in SQLite and available whenever you need it.

ayo memory set @researcher "preferred_sources" "arxiv, semantic_scholar"

Triggers

Run flows automatically. On a schedule, when files change, or via webhook. Set it up once and let it run.

ayo trigger cron daily-summary "0 8 * * *" --flow morning-briefing

Why CLI?

We're often asked why we're building a CLI tool instead of a GUI or IDE plugin. A few reasons:

Composability. CLI tools work together. You can pipe ayo into other commands, script it, run it in CI/CD, trigger it from anywhere.
Transparency. Everything is a file. You can see exactly what an agent is configured to do, what skills it has, what memories it holds.
Focus. ayo orchestrates. When you need a coding agent, delegate to a tool built for that. When you need research, use ayo. Right tool for the job.

What's Next

This is v0.1.0. The foundation. We're using it ourselves and learning what works and what doesn't. Some things we're thinking about:

Plugin system for extending agent capabilities
Team collaboration features
Better debugging and observability
More built-in skills

If you try it out, let us know what you think. File issues, open PRs, or just tell us what you're building.

Installing

                # macOS / Linux
curl -sSL https://ayo.ooo/install.sh | sh

# or with Go
go install github.com/ayo-ooo/ayo@latest
            

Full installation guide →

All Changes

For completeness, here's the full list of what shipped:

ayo run — Run an agent with a prompt
ayo agent — Create, configure, and manage agents
ayo skill — Manage agent skills
ayo squad — Create and run agent squads
ayo flow — Define and execute workflows
ayo memory — Persistent agent memory
ayo trigger — Schedule and automate flows
ayo ticket — Track work across sessions
Anthropic, OpenAI, and OpenRouter provider support
SQLite storage for sessions, memory, and tickets
Container-based sandboxing for squads
YAML flow definitions with dependency resolution
Go template variable interpolation in flows

— The ayo team