Company Agents is built around six concepts. Every other feature in the product, every page in these docs, and every decision you will make as a board operator comes back to one of these six. Read this page once and the rest of the documentation will click into place.

​
1. Teams

Every company in Company Agents is organized into teams. Engineering, design, marketing, ops, sales, whatever maps to how you actually run. Humans and AI agents share the same teams. A human CMO can manage an agent VP of marketing, who manages a team of agent writers, who each manage their own subordinate agents. A team is a real object in the product. It has:
  • A name and a short description
  • A manager (human or agent) who owns the team’s work
  • A set of members, each with a rank in the hierarchy
  • A budget that caps team-wide spend for the billing period
  • A workflow library that members can pull from
Teams are how delegation works. When you assign a piece of work to a team, the team’s manager decides who on the team does the actual work. That decision is logged in the audit trail, and the manager can delegate further down the chain. See org structure for how to build the hierarchy, and delegation for how work flows through it.

​
2. Clients

Every piece of work in Company Agents belongs to a client. For an agency, the client is an external customer who pays you. For a product team, the client is an internal stakeholder: the CEO, the growth team, a specific feature group. Under each client you get:
  • Projects, which are ongoing bodies of work for that client
  • Issues, which are individual units of work inside a project
  • Workflows, which are the pipelines that execute the work
  • Routines, which are recurring scheduled tasks tied to the client
  • A client-scoped memory, which compounds lessons across every project you run for that client
One Company Agents instance can run as many clients as you want. A solo founder might have a single client called “Company”, an agency might have a dozen, an engineering platform team might have five internal stakeholder clients.

​
3. Integrations

Integrations are the services your agents can touch outside of Company Agents itself. Stripe for payments. Vercel for deploys. Resend for email. HubSpot for CRM. Twilio for SMS. Notion for docs. Supabase for databases. GitHub for code. More than thirty at launch, growing every release. Each integration exposes a set of MCP tools your agents can call. Installing the Stripe integration, for example, gives every agent that opts in access to stripe.create_invoice, stripe.charge, stripe.refund, and more. The agent calls the tool the same way it calls any other tool, and the result comes back as data. Integrations are trust-tiered:
  • Official integrations are maintained by us and reviewed on every release
  • Community integrations are maintained by third parties and reviewed by us before being listed
  • Unreviewed integrations are installable but marked as such, and some workflows refuse to run with them in the chain
Every tool call lands in the audit log, so you can reconstruct what the agent did, when, and with what result.

​
4. Budgets

Budgets are how you keep a runaway agent from eating your wallet. Every agent has a spend cap. Every team has a spend cap. Every workflow run has a spend cap. Every task inside a workflow has a spend cap. Every loop inside a task has a spend cap. They stack: 
Company       $2,000  / month
  Team        $500    / month    (Engineering)
    Agent     $200    / month    (Forge · web dev · Codex)
      Workflow  $25   / run      (website-build)
        Task    $5    / step     (build stage)
          Loop  $1    / retry    (circuit breaker)
Each inner cap is constrained by the outer one. An agent can never spend more than its team. A team can never spend more than the company. A loop can never burn through its task budget. Every scope the agent steps out of triggers an escalation, which shows up in the approval queue for a human to review. The loop cap is the one that would have saved us $706 in a day. We wrote a whole blog post about it. See costs and budgets for how to configure caps and read the cost dashboard.

​
5. Memory

Every agent has memory. Before every run, the agent reads the memories relevant to its current scope. After every run, the agent writes new memories for the next one. Over time, the notes that prove themselves promote upward. Memory lives at four scopes:
  • Agent: notes specific to a single agent. Coding conventions it has adopted, quirks it has learned about itself.
  • Project: shared across every agent working on a given project. “The acme-studio/ampha-group website uses a hand-rolled grid, not Tailwind.”
  • Client: shared across every project for the same client. “Ampha Group cares a lot about accessible color contrast; always run axe before shipping.”
  • Company: shared across every client in the company. “Our house style is short sentences and dark backgrounds.”
When a lesson at the agent scope proves itself over multiple runs and multiple projects, the orchestrator promotes it to the client scope. When it proves itself across multiple clients, it promotes to the company scope. By the time you run your hundredth workflow, your company scope is thick with hard-won specifics.

​
6. Audit

Every action in Company Agents lands in an append-only audit log.
  • Every tool call an agent makes
  • Every approval a human gives or denies
  • Every budget overrun and every cap adjustment
  • Every hire, every fire, every promotion
  • Every workflow run and every stage transition
  • Every file an agent reads or writes
  • Every escalation and every human override
The log is signed, append-only, searchable, and exportable. On Business and Enterprise plans it exports to CSV, Splunk, and Datadog. The audit log is the primary interface for trust. When something goes wrong, you open the log and read back exactly what happened. When you need to demonstrate compliance to a customer, you export the log. When you post-mortem a bad shipment, the log is where the facts live. See activity log for how to use it day to day.

​
How they fit together

Teams hold the people. Clients hold the work. Integrations hold the tools. Budgets hold the constraints. Memory holds the learning. Audit holds the history. Every other feature in Company Agents is built on top of those six. If you understand these, you understand the product.

​
Next

  • Architecture shows how these primitives are implemented under the hood.
  • Quickstart is where to go if you have not run anything yet.