AI agents have started delegating work to one another and using business services directly. Adding A, for AI agent, to relationships traditionally described as B2C and C2C changes who uses software and how work moves between them. We can see this shift in SEASON’s ReviewOps and CloudStack products and in GitLab, which we use to manage development.
Agents have started using other agents
Among Databricks customers, use of multi-agent systems grew by 327% from July to October 2025. Multi-agent systems divide work among several agents. The Supervisor Agent, which delegates tasks to other agents and tools, accounted for 37% of Agent Bricks usage in October. Databricks 2026 report
In August 2026, Anthropic reported that around 30,000 agents were conducting research and development concurrently on one of its most active internal platforms, delegating tasks to one another. Anthropic’s internal usage figures

Relationships among businesses, consumers, and agents
B stands for business, C for consumer, and A for AI agent. A person asking an agent to plan a trip is an example of C2A. A business delegating development work to an agent is an example of B2A. An agent handing research to another agent is an example of A2A.

An API lets external software call a program’s functions. An agent calling the CloudStack or GitLab API is using a service in an A2B relationship. An agent that delegates a task to another agent and receives the result is collaborating in an A2A relationship.
What changed in our company’s services
On November 15, 2026, we connected to 18 of the 36 destinations configured in our work environment and examined service and development records. The destination count excludes duplicate SSH entries. The following examples come from work on ReviewOps, CloudStack, SEASONGRID, and GitLab.
For our internal rollout, we identified the functions we needed, decided where each would store information or execute work, and connected them to agents through APIs and permissions. Keeping reviews and attachments on a PC calls for a different setup from running a service on a server.
| Service and function | Where information is stored and work runs |
|---|---|
| ReviewOps Reviews and development work | Stores reviews, attachments, and task history in the desktop app. Codex runs on the selected development PC or server. |
| CloudStack Project and service management | Manages project and deployment information and access permissions on the server. Its API can list, create, start, and stop services. |
| SEASONGRID Deployment and image management | Connects Kubernetes deployments and image builds to the management API, where agents can read status and logs. |
| GitLab Requirements and code history | Records feature requests in issues and code changes in repositories. The API reads and writes the corresponding records. |
For SEASONGRID, we reviewed 80 Codex user messages saved on the server and organized recurring administration requests into 174 API operations. Agents can now call those operations using defined inputs and permissions for work that previously required someone to connect over SSH and find the right commands.
A research agent can read information, an execution agent can make authorized changes, and a review agent can examine the results. Defining the inputs, outputs, and available APIs for each role clarifies what the agents should pass between them.
ReviewOps: Connecting work requests with results
ReviewOps is SEASON’s tool for managing software reviews and improvements. In the desktop app featured here, users can look at a website, create a review for an improvement, and attach screenshots, error logs, and related files. The person in charge can send the review to Codex, run the work on a development PC or designated server, and inspect the progress and changes in the same review.
We used the same approach for server operations. On October 19, 2026, a single request covered a backup, an upgrade from GitLab EE 19.4.1 to 19.5.0, and post-upgrade checks. All 137 projects and 58 users were retained, and settings were preserved. No database migrations remained pending. User sign-in, code pushes, automated builds, and backup restoration were outside the scope of this test.
We also added a feature that lets a management agent read another agent’s completion response and store it in the original review. In a separate test project using a live model, the management agent saved one response without rerunning the original goal, and the review moved into the review stage. ReviewOps handled a step that previously required someone to copy a result from one conversation to another. ReviewOps development and execution records

CloudStack: APIs and permissions for each task
The CloudStack discussed here is SEASON’s own cloud service management product. Employees can create a project, choose a service configuration, and create, run, or stop development servers and databases. They can also manage the IP addresses and domains the project uses and the access each member has.
Agents use these features through an API. The API documentation and per-service connection instructions show agents how to connect through SSH or to services such as MySQL and Redis. Agents read instruction names and descriptions first and retrieve only the relevant instruction text and files.
API calls use an authentication token with read or write permissions selected for each function. CloudStack checks both what the token permits and which projects the account can access.
| Action | Permissions required together |
|---|---|
| List services or read their settings | Deployment read permission and permission to view the project |
| Create, start, stop, restart, or delete services | Deployment write permission and permission to manage services in the project |
| Delete a project | Write permissions for projects, deployments, IP addresses, and domains, plus project owner permissions |
Deployment write permission includes deletion. Even a full-access token is limited by the account’s access to individual projects.
On November 15, we changed system administrator tokens so they could list only projects the account was allowed to access. Group owners and administrators inherit admin permissions in child projects, while regular members use the permissions granted in each project. In a separate test environment, demoting a group administrator denied access with the same token. Restoring the role restored access. The role change took effect in the API without replacing the token.
CloudStack also provides a prompt for generating agent instructions for each token, including the API address, granted permissions, and conditions of use. This lets the person assigning a task tell the agent both how to use the tool and what it is allowed to do.
We also used A2A collaboration to improve project access. The lead agent assigned interface inspection, additional testing, and change review to three other agents. After combining the results, we passed 220 Java tests and 13 front-end tests and deployed the change to production.

GitLab: Writing requests the next person can act on
How we hand off work has also changed. A short GitLab request to deactivate projects and groups grew into nine usage scenarios and ten checks to run after implementation. It specifies what to do when services are still running, when stopping them fails, and when their status cannot be read. The issue remains open, and the ten items describe tests to run after implementation. An example GitLab issue
A society where agents hand work to one another
Handing off work in ReviewOps and setting up APIs and permissions in CloudStack gave us practical experience assigning distinct roles to agents and putting them to work. I expect the efficiency of A2A interactions to depend heavily on how the work is divided and the tools are configured.
I expect A2A interactions to account for the great majority of requests and responses exchanged at work. If we represent both the sender and recipient of a report as C, a report with an agent on one side follows C→A→C. When the recipient also starts using an agent, the path becomes C→A→A→C.
Agents will ask for missing information, check it against other material, and exchange revised versions. The same shift could apply to comparing quotes, coordinating schedules, and handling customer inquiries. People will spend more of their time assessing the results agents have assembled and making decisions, and less of it relaying and filling in the same information.
I expect total AI token usage to rise substantially as these interactions grow. A single request will prompt questions, replies, and reviews from several agents. The amount of information agents process among themselves will grow much faster than the amount people read directly.
Handling all that extra processing with large cloud models would increase costs, power consumption, and response times. I therefore expect growing demand for AI models small and efficient enough to run several agents at once on a mobile device. Small models on personal devices could handle day-to-day work, with large cloud models reserved for complex analysis. I expect it to become common for each person to use several agents that work with authorized tools and exchange results with other people’s agents.
