Companies of agents

Companies of any kind whose members are agents, with you as the CEO.

Companies of agents#

With Settings › Labs › Companies of agents on, More › Companies lets you build a company of any kind (a shop, an agency, a software project, a channel) whose members are agents. You are at the top, as the CEO.

A company's page has five parts: Team (the org chart and the roles), Work (tasks, meetings and the activity), Knowledge (context and rules, and memory), Governance (decision levels and costs) and Output (product, media and the showcase, when the company has them). On the phone one list picks the section. The header shows whether the company is working or paused and what it spent this month; Edit company and Pause company sit beside it, and ⋯ holds Export and Delete. A link with ?tab= (for example ?tab=costs) opens that section.
New company starts from A template (a software company with a product owner, a project manager, two developers, a CTO, marketing and finance; a marketing agency; an online shop; a content channel; a consultancy; or a blank one; its names, roles, responsibilities and context come in your language), from Describing it (say what the company does and a model proposes its departments, roles, members, context and routines; you see the proposal, and nothing is created until Create this company; capabilities Pimpo does not have are left out and said so), or Blank with a name, its industry and its mission. Import takes a company file someone shared. Export on a company's page saves it as a .company.yaml file; it carries the departments, roles and members, never who you are, and whoever imports it becomes its CEO.
Roles are the functions in the company: a title, what the role is for, its responsibilities and deliverables, the accounts it needs, the tools it may use and the models it may use. Several members can hold the same role. A role in use cannot be deleted.
Hire puts an agent in a role: a name, an avatar, a personality, a department, who it reports to and, if you want, fewer models than its role. Working off pauses it: it starts no new work. Remove from company, set apart at the end of its window, removes it after asking, and whoever reported to it reports to its boss. The avatar is the square at the top of the window: type an emoji or a letter; empty, it shows the name's first letter.
Departments group members on the org chart with a color.
Context and rules hold what members need to know and what they may do, for the whole company, a department, a role or one member. Each member receives the company's context first, then its department's, its role's and its own. For rules, the most specific one wins: the member's, then the role's, the department's and the company's. A rule that allows what a broader rule forbids asks to be saved as an exception, and stays marked with the rule it goes against. Company rules never go past the house's rules: a member's action takes the stricter of the two.
What this agent receives, in a member's window, shows its brief as the agent reads it and what each of its tools would do now (allowed, made reversible, asked first or never), with the rule that decides.
The org chart draws the company as a tree. Drag a card onto another to change who the boss is, or choose Reports to in the member's window; a member can never report to someone below it. On the phone the tree is a list.

Members work on their own:

Work and routines, in a member's window, has Give a task now (the agent does it as soon as it is free and on duty), its Routines with the agent (instructions on a schedule, every hour, every weekday at 8 or your own cron, each with what one run may spend, up to $5), and the Automatic routines you give it: your routines that run without a model as this member and wake its agent with company.wake when something new arrives.
A member's work is real: what it sends is sent. Every action still passes the house's rules and the company's, and only the tools of its role are within reach. One piece of work runs at a time per member and three per company; the rest waits in line.
Working hours, in Edit company, keep work for the days and hours you choose; what arrives outside them waits. A member can have hours of its own.
On the org chart a member that is working shows a blinking dot (hover it for the task), and a number shows how much waits. Work › Activity lists what members did, are doing and will do, with what each cost; Stop ends a piece of work.
Pause company stops every member, and a department or a member can be paused on its own: what they were doing stops and waits, and their routines do not run until you resume.

Members work together, and stop to ask:

Tasks shows the work handed between members, by state. New task hands one to a member with its objective and how to know it is done (both required), its constraints and what is out of scope. Members hand tasks to the people below them the same way (and to their department when Edit company allows it); Pimpo keeps each task's dossier, the links to where it came from, so whoever does it reads the original and not a summary of a summary. When a task is done or blocked, whoever gave it is told.
A handed-down task is checked against the task it comes from; one that may have strayed shows May have strayed from the goal and waits for its assignee's boss to say whether it starts. Pimpo refuses tasks that would make delegation run away: more than four levels deep, more than ten open tasks for one member, the same task twice, or work handed back up.
A member can stop and ask its boss before deciding. The question waits until it is answered, as long as that takes, and costs nothing meanwhile; the member takes other work in the meantime. A boss that is an agent answers it as work of its own (or asks its own boss); when the boss is you, the question reaches Needs you, your channels with the options as buttons, and the Tasks tab. With the answer, the work goes on from where it stopped, told what it already did.

The company remembers, meets and reports:

Memory holds what the company decided and learned: decisions, facts, lessons and the minutes of meetings. There are three: the Company's, which every member reads; each agent's own, which only that agent reads; and each task's, read by the work on it and on the tasks below it. Every member receives the latest with its brief, and looks further back with company.recall. What a member keeps with company.remember is shown as that member's words, never as a rule; only you forget a note.
How memory is written, on the same tab, says for each memory whether agents write to it freely, after a decision or not at all. By default they write freely to their own and their tasks' memory, and a note for the whole company waits under Waiting for approval (and in Needs) until you keep it; After a decision can also name the boss, Jev, a model or a committee. Keep a note after each piece of work has Pimpo note, by itself, what each finished piece of work did in its agent's or its task's memory.
Meetings let agents talk an agenda through. With I take part on, the meeting is yours: you talk with all its agents or with the ones you pick under Speak to (or name one with @), and they answer in turn, each hearing the others and knowing its recent work. Talk in a member's window opens a conversation with that agent alone, and Talk with on a question it asked you discusses it before you answer. Make it a task under any answer gives that agent work, with the conversation as its context. End with minutes keeps the minutes and decisions in the memory. Without you, two to eight agents talk for one to four rounds and the chair writes the minutes; a member can call one with company.meet. Meetings only talk, with no tools, and stop at their cost cap (up to $2).
Performance, on Work, shows how each agent did: work done and failed, minutes and cost for each piece, tasks closed and stuck, questions it asked, kinds of delivery it earned, and, where its role has them, how many of its briefs' predictions came true and how many of its videos pass their checks.
Showcase, a tab only the company's creator sees, is an optional public page at /showcase/<address> with only what you put on it: briefs that shipped, videos the company uploaded, and links. It shows the company's name, industry and mission and names no one, neither you nor the agents. It is off until you turn it on, and the world reaches it only if it reaches your Pimpo (for example with Tailscale Funnel).
Dashboards can show a company: its summary (who is working, questions waiting for you, spent today and this month) and its spending this month by day, under Companies when adding a widget. Only people who may view the company see them.
This week, at the top of Work, sums up what each member did and what it cost, the tasks closed and the questions waiting. On Mondays the same summary reaches you on your channels.

You choose who decides:

Autonomy, in a member's or a role's window, says who decides when an action would ask first: the agent itself, Jev or Laya with a minimum certainty (sure yes goes ahead, sure no is refused, unsure goes on), a model, the boss, a committee of members voting, a cascade of these, or you. A member's lines come first, then its role's, then the company's default, set in Decision levels; with none, you decide. What the administrator's own rules ask, and messages to other people, always reach a person. What this agent receives shows who decides each tool.
Decision levels say which decisions go up to whom. Use the four suggested levels (operational, tactical, managerial, strategic) or write your own: each level names who decides (the agent, its boss, the head of its department or you) and its triggers (an amount over a limit, a risk, kinds such as price or contract, being public, words). Each level reads as a sentence, when it applies and who decides, and its pencil edits it in place. A decision is at the highest level its triggers reach. Questions the triggers leave below the top are checked by Jev, and an unsure one comes to you. Strategic questions can reach you with the bosses' opinions on the way. No rule or autonomy takes a decision of your level away from you. The Simulator shows where a decision would land, and Decisions lists every answer given, by whom.
Earned autonomy: when you approve the same kind of delivery from a member several times in a row (10 by default) without saying no, Pimpo suggests letting it do that alone, in Needs. Let it do it alone adds a line to its autonomy, marked as earned; a no to that kind later takes it back to approval. The decision levels and what always asks a person stay above it. Set the number, or turn suggestions off, on Decision levels.

Costs have their owner:

Costs shows what the company spent today and this month, what it is likely to spend this month (from its routines and the pace of the last two weeks), and, per member, what it spent, how many pieces of work it finished, what each cost and its forecast. Every model call, judgment and meeting is booked for one member.
Limits sit in layers: the company's (a day and a month), a department's (a month) and each member's monthly salary, all inside your own limit and the house's. A company cannot be given more than your own daily limit. Near 80% of a limit you are told once that day; at the limit the agents stop until the next day or month, or, if you choose Only tell me, they go on and you are told. A piece of work never gets more than what is left.
Work paid by your subscription (Claude Code with a Claude plan, Codex with ChatGPT) costs no money per call, so dollar limits alone do not hold it back. On subscription shows what it would have cost on the API, and Count subscription work at API prices makes the limits count it too. When the subscription runs out of turns, the work waits an hour and tries again (up to six times) instead of failing.
Hire shows what a member in that role costs a month, from the others in it.
Finance: a member with costs.read reads a month of what the company spent with Pimpo, by member and department, against its budget and the month before, with what looks wrong: a day that spent more than twice the usual of the two weeks before it, or a member on pace for half again what it spent last month. With the Stripe connection (a restricted key that only reads the balance and charges) and github.sponsors, it also reads what comes in. On the first of each month it is asked to write the month's report, kept in the memory. It proposes budgets with company.budget_propose, for the company, a department or a member; they wait on Costs and in Needs, and only Apply changes the limit, within your own. Nothing a finance member does moves money.

Each agent has accounts of its own:

Own accounts, in a member's window, connects accounts for that agent only: its own mailbox, GitHub, Slack, Notion and any other connection Pimpo has. Each one says what kind of account it is: a service's, a machine's (where the service allows automation), the brand's, or a real person's. Pimpo warns when a service's terms may not allow that kind, such as an agent's personal profile on a social network; brand accounts are the safe choice there. A role can list the accounts it needs; its members wait until they have them, and the org chart shows a key when one is missing.
GitHub gives a developer, a reviewer or a product owner the work of a real team: reading a repository, its issues and pull requests, opening and editing issues, opening pull requests, reviewing them, reading their checks, merging and publishing releases. Merging, releases and comments are irreversible, so they go to whoever your rules and decision levels say before they happen. Give each agent a fine-grained token of its own, limited to the company's repositories.
Product: a product owner keeps what it hears with company.signal (the same page or nearly the same title heard again counts on the first, with every place it was heard) and proposes briefs with company.brief: the problem, the proposal, claims that each cite a source and quote the words that support them, scores from 1 to 5 and predictions of what will change. The score is 2 × value + differentiation + 2 × adoption − build risk − safety risk. Jev flags a claim whose quote does not support it, and a claim that quotes nothing is flagged too. Briefs wait for you on the Product tab and in Needs: accept or reject them, then Mark as shipped with where they shipped. On days 30 and 90 after that, the author is asked to check each prediction against what happened, and the tab shows how many came true. A project manager writes issues with acceptance criteria (github.issue_create turns them into a checklist) and gets its team's day with company.standup: what each member below it did, is on, waits for and is stuck on, to keep as a standup note.
Media: a content role makes videos on this computer. media.voice reads a text with the voice you chose for routines, media.capture takes a screenshot of a page in the agent's own browser (only hosts your rules allow, with Use a browser on in Labs), and media.render puts scenes of an image, a voice and a caption together with ffmpeg as a tutorial (16:9, up to 20 minutes) or a short (9:16, up to 60 seconds), its sound brought to −14 LUFS and its captions as a subtitle track. Every video is checked before anyone is asked about it: its length, its aspect, its loudness and its captions. The Media tab shows them with what the checks found. ffmpeg must be installed (on a Mac, brew install ffmpeg).
Publishing: youtube.upload sends a video that passed its checks to the company's channel, always as private and marked as made with AI; youtube.publish makes it public and, being irreversible, goes to whoever your rules and decision levels name; youtube.stats reads how it does. linkedin.post posts on the company's page. For a network Pimpo does not post to, such as Instagram or TikTok, publish.assisted sends the ready post to your phone to publish by hand. Connect YouTube (the channel's brand account) and LinkedIn (the company page) as accounts of the agent. Whatever a member publishes ends with the company's AI disclosure, which you can word in Edit company but not leave out.
Coding: a role with code.workspace codes. In the member's window, Coding picks the CLI it codes with (Claude Code, Codex or opencode, with a model if you want one) and whether it codes in that CLI's sandbox, where commands write only in the task's folder; opencode has none, and without it commands run on your computer as you do. Each task gets its own git worktree and branch (pimpo/<member>/<task>); the CLI changes the files, Pimpo commits them as the agent and pushes the branch with the agent's GitHub token, and the agent opens the pull request with github.pr_create. The CLI gets none of your keys nor your git credentials. Variables for coding, in Edit company, are given to the CLIs, one NAME=value per line; they are not for secrets. When a task is done its worktree goes away; what was pushed stays on GitHub.
The company's accounts, on the Costs tab, are shared ones (the official channel, the support inbox) with what each agent may do: nothing, read, or act. An agent uses its own account first, and the company's only when it was given it.
An agent never uses your accounts, or another agent's. It never reaches your phone, your Mac's apps, your house, your Google account, your music, your notes or your memory, and it browses with a browser profile of its own, never with the sites you signed in to.

A company is yours alone, like your routines: nobody else in the house finds it, the administrator included. Shared with someone as a partner, they see it with what they were given (view, approve or configure); only you delete it or change who it is shared with.

This page is built from the repository's documentation. Improve it on GitHub.