The Self-Driving Company Is Taking Shape

What's the difference between these two instructions?

If you run a company, one way to think about your people is whether they are task owners or product owners.

Task owners take responsibility for tasks. Give them a clear problem, and they'll work through it. You can trust them to deliver.

Product owners take responsibility for running an area of business. They decide what needs doing, do (or delegate) the work, and figure out what comes next. You can trust them to move things forward without waiting to be told.

Today, most of us use agents as task owners. Fix this bug. Research this account. Update this page. We define the work, the agent carries it out, and we verify the result.

For companies to become self-driving, agents need to move from task owners to product owners. They need to understand what they are responsible for, recognize when something needs attention, and follow through on useful work.

Humans will still set the direction, define the products, and remain accountable for the outcome. The shift is that they can delegate an ongoing responsibility without having to identify and assign every task themselves.

What Makes a Company Self-Driving?

A self-driving company is where people define areas of responsibility (called products), and agents figure out what needs doing, break the work into projects and tasks, and see it through to completion.

People define each product's purpose, set priorities, and approve the projects worth pursuing. Agents use the company's knowledge and systems to spot problems, propose improvements, and carry out approved work. They check the results and keep looking for what needs attention next.

People remain accountable for the outcome, but they no longer have to identify and babysit every task. They set the destination and approve the route. Agents do the driving.

How to Build Your Own Self-Driving Company

It would be odd if I introduced the self-driving company and didn't show you how to build it.

Agno's agent platform, called AgentOS, includes a feature called CompanyOS, which gives agents context about your company and the work they are responsible for.

You define Products and give the agents Sources to pull information from. Routines run agents on a schedule to review the Sources, identify useful work, and propose Projects and Tasks. You decide which work to approve, and agents carry it out and bring the results back for review.

AgentOS is the runtime that orchestrates the agents, connects them to tools, and manages their sessions, storage, and schedules. CompanyOS organizes the work, and AgentOS runs the agents that do it.

We start with a Product called AgentOS, responsible for improving the platform itself. Its Sources are the codebase and Agno releases, and its maintenance Routine reviews them for useful improvements.

Here is a shortened version of that definition in app/company.py:

from pathlib import Path
 
from agno.company import Product, Routine, Source
 
products = [
    Product(
        id="this-agentos",
        name="AgentOS",
        purpose="Improve this AgentOS by scanning this codebase and Agno releases.",
        sources=[
            Source(type="git", reference=str(Path(__file__).resolve().parents[1])),
            Source(type="website", reference="https://github.com/agno-agi/agno/releases"),
        ],
        routines=[
            Routine(
                name="agentos-maintenance",
                executor_type="agent",
                executor_id="company-manager-internal",
                cron_expr="0 9 * * *",
                instructions="""
Review this codebase and Agno releases since the pinned version.
Check existing work, then propose up to three useful improvements
as Backlog Tasks in suitable Projects. Include evidence and a way
to verify each change. Reuse existing proposals.
Do not accept or execute work. If nothing needs changing, create no work.
""",
                enabled=False,
                auto_accept=False,
            ),
        ],
    ),
]

Once the routine is enabled, it asks the built-in Company Manager to review the codebase and releases every day at 09:00 UTC. If it finds improvements, it proposes projects, with evidence for why each change matters and a way to check the result. AgentOS runs the agent; CompanyOS runs the company.

Suppose a new Agno release introduces a capability that could replace custom code in the platform. The routine could identify the opportunity and propose a focused Project, with Tasks to update the implementation, test the behavior, and revise the documentation. A person reviews the proposal and chooses which work to accept. A configured coding agent can then carry out the accepted Tasks and bring the changes back for review.

We can add routines that investigate incidents, review support conversations, or look for patterns in customer feedback.

Where are we today?

We're on the doorstep of the self-driving company. Coding agents can carry out longer pieces of work with the right tools, context, and checks. We're still learning how to give them an ongoing responsibility and trust them to identify the right work, follow through, and improve the result over time.

At Agno, we're organizing our work into Products like the SDK, website, backend, API, marketing, and growth. Each gets a defined purpose, relevant Sources, and Routines to look for useful work. We want agents to connect recurring GitHub issues to SDK improvements, find gaps in the website, and turn customer questions from email and Slack into proposed features, fixes, and documentation updates.

We're starting small and seeing how this evolves. How large should a project be? Which kinds of agents make the best product owners? Which changes actually help? How much of the work can agents carry through without someone directing every step? What we learn will shape both how we run Agno and the platform we're building for others.

If you want to take this for a spin, try it in your company, or build alongside us, reach out.