MAX
← Все материалы AI Playbook← All AI Playbook articles
AI native company playbook

Как построить AI native компанию, где каждый сотрудник может менять продуктHow to build an AI native company where every employee can change the product

Как связать стратегию CEO, самостоятельность сотрудников и AI-агентов, чтобы люди сами улучшали свой участок продукта и отвечали за результат.Connect the CEO’s strategy, employee autonomy and AI agents so people can improve their part of the product and own the outcome.

Максим ТолмачёвMaxim Tolmachev~9 мин чтения~9 min read

Я хочу, чтобы сотрудник поддержки после жалобы клиента мог сам исправить проблему в продукте. Разобраться вместе с агентом, проверить исправление и выпустить его. Чтобы коммерческий директор мог собрать себе отчёт по продажам, а бухгалтер сделать форму, которую давно просит у разработки.

Вот что я имею в виду под AI native компанией. Каждый сотрудник становится мини-CEO на своём участке: понимает стратегию компании, сам решает, что улучшить, и может довести изменение до пользователя. Дальше смотрит, помогло ли оно, и отвечает за последствия.

Мне интересно, как собрать такую компанию целиком: с культурой самостоятельности, общей базой знаний, агентами и доступом к рабочим сервисам. Ниже моя рабочая модель, целиком в одной организации я её пока не проверял.

Что сотрудник должен понимать без созвона с CEO

Если CEO говорит “растём и используем AI”, сотруднику всё ещё приходится угадывать, какие изменения нужны бизнесу. Агент будет угадывать вместе с ним, только быстрее.

Я хочу, чтобы по стратегии сотрудник мог принять решение без очередного созвона. Для этого ему нужно знать, для кого мы строим продукт, какой результат сейчас важнее и чем ради него готовы пожертвовать. И отдельно понимать, какие направления пока вообще не трогаем.

Дальше договариваемся, за что конкретно отвечает человек и что он может менять. Например, поддержка отвечает за то, чтобы новые пользователи успешно проходили настройку. Она может менять инструкции, подсказки и оговорённую часть интерфейса. Изменения авторизации, оплаты и хранения данных уходят на дополнительное ревью. Снижение числа обращений оцениваем вместе с успешностью настройки: спрятать кнопку поддержки тоже уменьшит обращения, но вряд ли поможет пользователю.

В таком договоре мне нужны пять вещей:

  1. Результат для клиента и метрика, по которой мы его проверяем.
  2. Участок продукта или процесса, за который отвечает сотрудник.
  3. Решения, которые он принимает самостоятельно.
  4. Ограничения по бюджету, данным и влиянию на соседние участки.
  5. Условия, при которых он привлекает другого владельца или CEO.

Иначе продажи пообещают клиенту новую фичу, поддержка предложит убрать её из продукта, а каждый будет прав в рамках своей метрики. Заранее договариваемся, кто разбирает такие конфликты и на что опирается.

Если за инициативу наказывают, агенты не помогут

И вот здесь, мне кажется, начинается самое сложное. Если за любую неудачную инициативу наказывают, люди продолжат ждать задач сверху. Если оценивают по числу выпущенных изменений, быстро появится много изменений без пользы.

Мне важнее, какую проблему человек взялся решать и что выяснил после запуска. Гипотеза может не сработать. Если эксперимент был ограничен по масштабу, а изменение вовремя откатили, это нормальная работа. Хуже, когда причину провала никто не разобрал и через месяц всё повторяется.

Руководитель помогает человеку принимать решения и разбираться в последствиях. Инженеры строят общие компоненты, проверяют сложные изменения и делают путь в production предсказуемым. Их компетенция особенно нужна там, где сотрудник пока не может оценить качество работы своего агента.

Сотруднику должно быть нормально сказать: “Я не могу оценить этот код, мне нужен инженер”. И так же нормально остановить чужое опасное изменение, даже если его автор выше по должности.

Где сотрудник работает с агентами, данными и продуктом

Окей, с ответственностью договорились. Теперь сотруднику нужно где-то работать: найти данные, дать задачу агенту, посмотреть, что получилось, и выпустить изменение. Я раскладываю эту среду так.

Часть системы Что в ней хранится или происходит
Стратегия и задачи Цели, приоритеты, владельцы, критерии результата, статус работы
Профили людей и агентов Роль, область ответственности, доступные инструменты, бюджет
База знаний Решения, документы, звонки, инструкции с источниками и датами
Рабочие сервисы CRM, финансы, поддержка, аналитика, внутренние приложения
Среда создания изменений Отдельные рабочие копии, тестовые данные, preview, проверки
Выпуск и наблюдение Версии, правила релиза, метрики, журнал действий, откат

Привычную систему документов и готовую CRM можно оставить. Собственный сервис имеет смысл писать там, где существующие инструменты мешают выполнить конкретную задачу.

Здесь легко увлечься и начать собирать огромный дашборд, который заменит вообще всё. Я бы сначала провёл один сценарий через уже работающие сервисы. Где сотрудник застрял, туда и стоит прикладывать разработку.

У каждого агента есть владелец и профиль

Профиль человека описывает его ответственность, рабочий контекст и предпочтения. Профиль агента описывает порученную роль, инструменты, область данных, лимиты и способ эскалации. У одного человека может быть несколько агентов, и им не обязательно нужны одинаковые права.

Контекст для конкретной задачи собирается последовательно:

Стратегия компании → правила команды и домена → профиль сотрудника → профиль агента → задача и критерии приёмки → нужные материалы.

Например, агент коммерческого директора читает сделки и продуктовую аналитику, строит отчёт и предлагает изменения в процессе продаж. Доступ к зарплатам ему для этого не нужен. Если он готовит скидку за пределами полномочий владельца, задача переходит к ответственному за такое решение.

У инструкций и skills нужны версии, иначе потом не разберёшься, по каким правилам работал агент. Секреты храним отдельно, права проверяем на стороне сервиса или шлюза доступа. Если агенту нельзя отправлять платёж, API должен отклонить такую попытку, даже если агент проигнорировал инструкцию.

Что агенту разрешено делать в CRM, финансах и аналитике

Сотрудник просит “собери отчёт по причинам потери сделок”. Агенту нужны чтение CRM, согласованное определение потерянной сделки и возможность сохранить отчёт. Полный доступ ко всей базе для такого отчёта ему ни к чему.

Агентам можно открыть конкретные операции: прочитать сделки своего отдела, подготовить платёж, создать черновик ответа, собрать preview приложения. Подключаться можно через MCP или обычный API. Кто и что может сделать, определяют правила компании и проверки на стороне сервисов.

Для небольшой команды можно начать с нескольких прямых интеграций с ограниченными правами. По мере роста единый шлюз помогает проверять пользователя и агента, применять ограничения, выдавать нужные credentials и записывать действия. Строить свой шлюз заранее я бы не стал. Сначала нужно понять, какие ограничения уже трудно поддерживать в отдельных интеграциях.

Внутренние приложения, эксперименты сотрудников и клиентский production должны иметь раздельные доступы и данные. Рабочая копия кода не изолирует общую базу, порты и внешние API. Для песочницы нужно отдельно определить, к каким ресурсам она подключается.

Как звонки и решения попадают в общую базу знаний

Когда агент отвечает по базе знаний, я хочу видеть, откуда взялся ответ и насколько он свежий. Кто принял это решение? Для какого продукта оно действует? Документ ещё актуален или его уже заменили? Без этого поиск может уверенно принести старую инструкцию.

Со звонками я вижу такой процесс: получаем транскрипт, агент собирает договорённости и прикладывает ссылки на фрагменты разговора. Участники проверяют, всё ли он понял правильно. После этого назначаем ответственных и обновляем документацию. Мне не хочется через неделю обнаружить, что случайную реплику со звонка агент уже использует как принятое решение.

Контекст удобно собирать вокруг объекта работы: клиента, сделки, обращения, эксперимента. Внутри находятся относящиеся к нему документы, переписка, решения и результаты. Так агенту проще дать достаточный контекст, сохранив границы доступа.

AI-поиск поможет найти документ. Следить за тем, чтобы документы не противоречили друг другу и были доступны нужным людям, всё равно кому-то придётся.

От жалобы клиента до исправления в продукте

Разберу на примере, как это должно работать. Допустим, пользователи бросают настройку из-за непонятной ошибки в форме. Поддержка видит одни и те же обращения и берётся исправить причину.

  1. Собирает примеры и формулирует ожидаемое поведение. Агент помогает воспроизвести проблему и проверить, сколько пользователей она затрагивает.
  2. Создаёт задачу с владельцем, границами изменения и критерием приёмки. Привязывает её к цели успешной настройки.
  3. Агент готовит исправление в изолированной среде и показывает preview. Сотрудник проверяет сценарий глазами пользователя.
  4. Тесты проверяют исправленный сценарий и связанные с ним функции. Если изменение затрагивает чужой участок, его смотрит ответственный за этот участок.
  5. Исправление выпускают по заранее согласованным правилам. До релиза понятно, какую версию выпускаем и как её откатить.
  6. После релиза владелец смотрит на успешность настройки, ошибки и повторные обращения. Только здесь можно говорить о результате.

Для ограниченных изменений можно заранее разрешить автоматический выпуск при выполнении проверок. Изменения платежей, прав доступа, структуры данных или общих компонентов требуют другого уровня контроля. Больше самостоятельности можно давать после того, как команда научилась проверять свои изменения и откатывать их при проблемах.

Отдельный вопрос, который меня здесь волнует: кто будет проверять весь этот поток PR? Агенты могут писать быстрее, чем команда успевает читать. Поэтому изменения нужны небольшие, с ограничением на количество одновременно открытых задач и понятной очередью интеграции. Иначе будем ждать ревью вместо того, чтобы ждать разработку.

Какие инструменты здесь нужны

Когда процесс понятен, уже можно выбирать, чем его собрать. Например, Paperclip предлагает цели, задачи, роли агентов, бюджеты, согласования и историю работы. Его можно рассмотреть для управления работой агентов. Права и правила выпуска всё равно придётся настроить под свою компанию.

Кроме этого нужны сами агенты, база знаний с правами доступа и репозиторий с настроенным выпуском изменений. Личный интерфейс сотрудника может отличаться от интерфейса коллеги. Общими должны быть договорённости, данные и проверяемый статус работы.

Разницу между рабочими интерфейсами, исполнителями и агентами-координаторами я разбираю в personal playbook.

С чего я бы начал внедрение

Я бы взял одну повторяющуюся проблему и нашёл человека, который готов за неё отвечать. Сначала записываем, сколько времени и ручной работы она требует сейчас. Затем даём человеку нужные данные, агента и возможность самому дойти до preview и выпуска.

В пилоте мне важно понять, стало ли быстрее исправлять проблему и сколько человеческого времени съели ревью и переделки. Отдельно считаем стоимость, разбираем остановленные действия и ошибки. Экономия на написании кода мало радует, если потом вся команда неделю чинит последствия.

Если человек стал быстрее доводить полезные изменения до пользователей, можно расширять его полномочия и повторять процесс на соседнем участке. Если стало больше отчётов и PR, а проблема клиента осталась, добавлять ещё агентов рано.

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, 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.

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.