# How to build an AI native company where every employee can change the product

Connect the CEO’s strategy, employee autonomy and AI agents so people can improve their part of the product and own the outcome.

Author: Maxim Tolmachev
Published: 2026-10-04
Language: en
Canonical: https://maximtolmachev.com/en/ai-playbook/company/operating-model/

I want a support specialist to be able to fix a product problem after a customer reports it. Work through it with an agent, check the fix and ship it. I want the sales director to build their own sales report, and an accountant to create the form they have been waiting for engineering to make.

That is what I mean by an AI native company. Each employee becomes a mini-CEO of their own area: they understand the company strategy, decide what to improve and can get the change to a user. Then they check whether it helped and take responsibility for the consequences.

I am interested in how to put the whole company together this way, including a culture of autonomy, shared knowledge, agents and access to working services. This is my working model. I have not tested all of it together in one organization yet.

## What an employee should understand without another call with the CEO

If the CEO says “let’s grow and use AI,” employees still have to guess which changes the business needs. Their agents will be guessing alongside them, just faster.

I want strategy to help someone make a decision without another call. They need to know who we are building for, which outcome matters most right now and what we are prepared to give up to get it. They also need to know which areas we are leaving alone for now.

Then we agree on what the person owns and what they can change. For example, support owns successful setup for new users. They can change instructions, hints and an agreed part of the interface. Changes to authentication, payments and data storage need additional review. We assess fewer support requests alongside setup success: hiding the support button would also reduce requests, but would hardly help the user.

I need five things in that agreement:

1. The customer outcome and the metric we use to check it.
2. The part of the product or process the employee owns.
3. Decisions they can make independently.
4. Limits on budget, data and effects on neighboring areas.
5. Conditions for bringing in another owner or the CEO.

Otherwise sales will promise a new feature, support will suggest removing it, and both will be right according to their own metrics. We agree in advance who resolves these conflicts and what informs the decision.

## Agents will not help if initiative gets punished

This is where I think the hard part starts. If every unsuccessful initiative gets punished, people will keep waiting for instructions. If we measure people by the number of changes shipped, we will get plenty of changes with little benefit.

I care more about the problem someone chose to solve and what they learned after launch. A hypothesis can fail. A small experiment followed by a timely rollback is normal work. It is worse when nobody looks into the failure and the same thing happens a month later.

Managers help people make decisions and understand the consequences. Engineers build shared components, review complex changes and make the path to production predictable. Their expertise matters particularly when an employee cannot yet judge the quality of their agent’s work.

An employee should feel comfortable saying, “I cannot assess this code, I need an engineer.” They should be just as comfortable stopping someone else’s dangerous change, even when that person is more senior.

## Where employees work with agents, data and the product

Okay, we have agreed on ownership. Now the employee needs somewhere to work: find data, give an agent a task, see the result and release a change. I break that environment down like this.

| Part of the system | What it holds or does |
| --- | --- |
| Strategy and tasks | Goals, priorities, owners, acceptance criteria, work status |
| Human and agent profiles | Role, scope, available tools, budget |
| Knowledge base | Decisions, documents, calls and instructions with sources and dates |
| Working services | CRM, finance, support, analytics, internal applications |
| Development environment | Separate working copies, test data, previews, checks |
| Release and monitoring | Versions, release rules, metrics, action logs, rollback |

You can keep the document system and CRM you already use. A custom service makes sense where existing tools get in the way of a specific task.

It is easy to get carried away building a giant dashboard to replace everything. I would first take one workflow through the services that already work. Develop the parts where the employee gets stuck.

## Every agent has an owner and a profile

A person’s profile describes their responsibilities, working context and preferences. An agent’s profile describes its assigned role, tools, data scope, limits and escalation path. One person can have several agents, each with different permissions.

Context for a task comes together in order:

> Company strategy → team and domain rules → employee profile → agent profile → task and acceptance criteria → relevant materials.

For example, the sales director’s agent reads deals and product analytics, builds a report and suggests improvements to the sales process. It does not need access to salaries. If it prepares a discount beyond its owner’s authority, the task goes to the person responsible for that decision.

Instructions and skills need versions so we can later establish which rules an agent was following. Store secrets separately and enforce permissions in the service or access gateway. If an agent cannot send a payment, the API must reject the attempt even if the agent ignores its instructions.

## What agents can do in CRM, finance and analytics

An employee asks for a report on why deals were lost. The agent needs CRM read access, an agreed definition of a lost deal and somewhere to save the report. It does not need full access to the database.

You can expose specific operations: read the department’s deals, prepare a payment, draft a response or build an application preview. Use MCP or a regular API. Company policy and service-side checks determine who can do what.

A small team can start with a few direct integrations with limited permissions. As the system grows, a shared gateway can check the user and agent, apply limits, supply credentials and record actions. I would not build a custom gateway ahead of time. First find out which restrictions have become difficult to maintain across individual integrations.

Internal applications, employee experiments and customer production need separate access and data. A working copy of the code does not isolate a shared database, ports or external APIs. Define separately which resources a sandbox can connect to.

## How calls and decisions enter the knowledge base

When an agent answers from a knowledge base, I want to see where the answer came from and how recent it is. Who made this decision? Which product does it apply to? Is the document still valid or has it been replaced? Without that information, search can confidently return an obsolete instruction.

For calls, I would use this process: get a transcript, have an agent collect the agreements and link to the relevant parts of the conversation. Participants check that it understood them correctly. Then assign owners and update documentation. I do not want to discover a week later that the agent treats a passing remark as an approved decision.

It helps to organize context around the object of work: a customer, deal, support request or experiment. Keep the relevant documents, messages, decisions and results together. That makes it easier to give an agent enough context while respecting access boundaries.

AI search helps find a document. Someone still has to keep documents consistent and accessible to the right people.

## From a customer complaint to a product fix

Here is how this should work. Suppose users abandon setup because a form shows a confusing error. Support keeps seeing the same requests and takes on the cause.

1. Collect examples and describe the expected behavior. An agent helps reproduce the problem and check how many users it affects.
2. Create a task with an owner, scope and acceptance criteria. Link it to the goal of successful setup.
3. The agent prepares a fix in an isolated environment and shows a preview. The employee checks the flow from the user’s perspective.
4. Tests check the repaired flow and related functionality. If the change touches another area, its owner reviews it.
5. Release the fix under the agreed rules. Before release, know which version is going out and how to roll it back.
6. After release, the owner checks setup success, errors and repeat requests. Only then can we talk about the outcome.

For limited changes, automatic release can be authorized in advance when checks pass. Payments, permissions, data structures and shared components need a different level of control. Give the team more autonomy as it learns to verify changes and roll them back when needed.

One question concerns me here: who will review this stream of PRs? Agents can write faster than a team can read. Keep changes small, limit the number of open tasks and maintain a clear integration queue. Otherwise we will be waiting for review instead of development.

## Which tools this needs

Once the process is clear, we can choose tools. [Paperclip](https://github.com/paperclipai/paperclip), for example, offers goals, tasks, agent roles, budgets, approvals and work history. It is an option for managing agent work. You still need to configure permissions and release rules for your company.

You also need the agents themselves, a knowledge base with access controls and a repository with a working release process. Employees can use different interfaces. Agreements, data and verifiable work status should be shared.

I cover the differences between interfaces, workers and coordinating agents in the [personal playbook](/ai-playbook/personal/agent-stack/).

## Where I would start

I would choose one recurring problem and find someone willing to own it. First record how much time and manual work it takes today. Then give that person the data, an agent and a way to take the work through preview and release themselves.

In the pilot, I want to know whether the problem gets fixed faster and how much human time review and rework consume. Track costs separately, and investigate blocked actions and mistakes. Saving time on coding means little if the whole team spends the following week fixing the consequences.

If the person gets useful changes to users faster, expand their authority and repeat the process in a neighboring area. If we get more reports and PRs while the customer’s problem remains, it is too early to add more agents.
