Introducing CompanyOS

Put agents to work without prompting.

Today we're launching CompanyOS, a new part of AgentOS that tells your agents about the company they work for and the Products they work on, so they can get to work without being prompted.

Turn it on by setting company=CompanyConfig() and defining the Products you want them to own. Agents identify what needs attention, propose Projects and Tasks, and execute once the work is approved.

Every company has work that never makes the roadmap. Documentation falls behind with each release, GitHub issues wait for triage, and on Friday someone pieces together a status update from Slack threads, meetings, and memory. Meanwhile, customer conversations reveal bugs, gaps, and feature requests that someone needs to turn into a plan. Everyone agrees this work matters, but nobody has time to own all of it.

Agents should be able to take care of this work. They should understand the product they work on, recognize what needs attention, and get started without waiting for someone to write a prompt.

CompanyOS gives them the context and structure to do that. Every company is a collection of Products. Products define what your agents are responsible for. Sources give them the information they need. Routines use that information to propose work, and Projects and Tasks organize its execution. You give an agent an area of responsibility, and it keeps working on it.

How CompanyOS works

Products, Projects, and Tasks

CompanyOS organizes work into three levels.

• A Product is an ongoing area of responsibility. At Agno, we have Products for the SDK, website, documentation, growth, marketing, and operations. Each describes what agents are responsible for, the outcomes they should work toward, and the Sources they should consult, such as repositories, documentation, and company knowledge.
• A Project is a specific outcome within a Product. It groups related work and closes when that outcome is achieved. Agents keep Projects small and focused, so each one has a clear outcome and people have a concrete result to review.
• A Task is an individual piece of work within a Project. An agent executes it and brings the result back for review.

You define the Product's responsibilities and goals. CompanyOS uses Routines to propose the Projects and Tasks needed to move it forward.

Routines

Routines turn a Product's responsibilities into executable work.

A Routine periodically reads the Product's Sources, checks existing Projects and Tasks, and identifies what needs attention. It can propose a new Project, add Tasks to an existing one, or leave things alone when there's nothing useful to do.

For a documentation Product, a Routine might check recent SDK changes, identify documentation that needs updating, and propose a Project with Tasks for the affected pages. Your team reviews and approves the proposed work, and agents execute it.

The team's role becomes defining responsibilities, setting direction, approving work, and reviewing results. Routines keep looking for what needs doing, so nobody has to keep writing the task list.

Turning customer feedback into product improvements

Consider a Product responsible for identifying and addressing gaps in your customer experience. Its Sources include GitHub issues, support channels, customer conversation notes, and emails. Its goal is to turn what customers are telling you into product improvements.

A Routine reviews those Sources and checks them against existing work. A support thread describes a customer exporting records one at a time. An email asks for bulk downloads. A GitHub issue requests an export API. Together, they point to the same gap: customers need a better way to get their data out.

The agents connect that evidence and propose a Project for bulk export. They describe the customer need, investigate the codebase, propose an implementation approach, and break the work into Tasks covering implementation, tests, and documentation.

An engineer reviews the proposal, adjusts the scope if needed, and approves the work. Agents then carry it through implementation, testing, and documentation, bringing the completed change back for review.

The engineer doesn't have to collect the feedback, spot the pattern, write the project brief, or work out the implementation plan. They can start with the evidence and a proposed solution, then decide whether it is the right work to pursue.

The Routine keeps running as new feedback arrives, adding relevant evidence to existing work and proposing new Projects when it finds another gap.

Getting started

Let's build a CompanyOS with one Product, a few Sources, and one Routine. We'll create a Customer Feedback Product and ask Company Manager to review its Sources every morning. Here's what the code looks like:

from pathlib import Path
 
from agno.company import Product, Routine, Source
from agno.job_queue import QueueConfig
from agno.models.openai import OpenAIResponses
from agno.os import AgentOS, CompanyConfig, OSManager
 
from agno.db.postgres import PostgresDb
 
db = PostgresDb()
model = OpenAIResponses(id="gpt-6.1-sol")
 
feedback = Product(
    name="Customer Feedback",
    purpose="Turn customer feedback into useful product improvements.",
    sources=[
        Source(
            type="markdown",
            reference=str(Path("feedback").resolve()),
        ),
    ],
    routines=[
        Routine(
            name="review-feedback",
            executor_type="agent",
            executor_id="company-manager-internal",
            cron_expr="0 9 * * *",
            timezone="UTC",
            instructions=(
                "Read customer feedback and check existing Projects and Tasks. "
                "Identify recurring bugs, gaps, and feature requests. "
                "Propose focused Projects and Tasks with supporting evidence. "
                "Reuse existing work and leave proposals for human approval. "
                "If nothing needs attention, create no work."
            ),
            auto_accept=False,
        ),
    ],
)
 
agent_os = AgentOS(
    db=db,
    manager=OSManager(model=model),
    company=CompanyConfig(model=model, products=[feedback]),
    queue=QueueConfig(durable=True, db=db),
    scheduler=True,
)

The Routine checks for work every morning at 09:00 UTC and proposes Projects and Tasks for human approval.

This example reads local Markdown files, but you can also use local Git repositories and websites as Sources. It sets up discovery and proposals only. To execute accepted Tasks, you'll need an agent with the right tools, and OS Manager can help you build one.

Build your company one conversation at a time

With your platform running and connected to os.agno.com, you can chat with Company Manager and OS Manager to build your company one conversation at a time.

Company Manager

Company Manager helps you create Products and Routines, propose Projects and Tasks, and understand what's happening across your company.

For the Customer Feedback Product, you could ask:

Review our customer feedback and propose the most useful product improvements. Group related requests, include the supporting evidence, and check whether we already have work underway.

You can also ask it to set up another responsibility:

Create a Documentation Product to keep our guides accurate. Help me define its Sources and a Routine that checks for outdated content every morning.

As work progresses, you can ask:

What's waiting for my approval? Show me the proposed work, why it matters, and what evidence supports it.

OS Manager

OS Manager helps you create the agents that will do the work, using the models and tools available in your AgentOS.

For the Documentation Product, you could ask:

Create a documentation agent that can draft guide updates from our product documentation.

Company Manager organizes the work. OS Manager helps build the agents.

Try CompanyOS

We want CompanyOS to get better at the full loop: understanding what matters, finding useful work, and carrying it through to a result your team can review.

CompanyOS is part of AgentOS. To try it, start with an AgentOS template. Head to agno.com, choose where you want to run your platform, and copy the setup prompt into your coding agent. Ask it to set up CompanyOS and help you define your first Product.

Start with one responsibility you'd like to take off your team's plate. Give it Sources, set up a Routine, and see what it proposes.

We'd love to hear what it gets right, where it gets stuck, and what you'd like it to take on next.