EXTREMELY agency

Your own agency and every organization you are in, with your role in each and whether it answers right now. Pass one as `agency` to any other tool.

Takes no parameters.

Requests agents filed for things they can't do themselves: what they need, why, where each stands, and the conversation with the Agency Engineer.

Close a request: done (say what was done, so the agent knows) or rejected (anything drafted for it is discarded). The agent hears on its next run.

Write in an open request, to the Agency Engineer (as in the app: everyone on the request sees it, and the Engineer is woken to answer).

Give an agent a job, from you: it starts on it as soon as it can and marks it done with the result (agent_activity shows it). For a question or a quick word, run_agent with a message instead.

Every agent: id, name, department, owner, state (active / draining = standby / stopped), ferocity level, models, and whether it is built in.

An agent's files (CHARTER.md, TOOLS.yaml, KPI.yaml), its models and state, its last runs and its memory notes.

Replace one of an agent's files: CHARTER.md (its job), TOOLS.yaml (tools, tiers, approval windows, ferocity plan) or KPI.yaml (which actions count as output). read_agent first. Its next run uses it.

The AI models connected in the app, which agents can be given (set_agent_models).

An agent's models: up to three, in order of preference; it falls to the next when one fails. Each {connection, model, effort: low|medium|high|max}, from list_models.

An agent's ferocity (how hard it works: Chill, Steady, Driven, Relentless, Apocalyptic) or state (active, draining = standby: starts nothing itself, stopped: runs nothing). Built-in agents have neither.

Read this first when making an agent: the agent builder's whole brief - how agents work here, the tool catalogue and default tiers, the tools every agent gets, this organization and the person, the fleet, connected services and their tools and events, the connected models, how to interview the person, and how to tier. create_agent's fields carry the rest.

Check a build before creating it, without creating anything: the same input as create_agent. Answers with what's wrong, or what it would make.

Add a new agent, as the app's agent builder would (read builder_guide first, and talk to the person the way it says): the full build - name, department, Charter, tools with tiers, events, KPIs, models, ferocity plan. Every id must exist (the guide lists them) or be one of its own new_tools / new_events, which go to the Agency Engineer as requests. Answers with what it made.

Delete an agent: its files go, its approvals and requests are closed, work handed to it is closed as not done. Its past runs stay in Usage. Built-in agents can't be deleted.

Start an agent now. With a message, it answers it in its DM channel (as if the person wrote it); without, it does its job as on Run now.

Agents' actions waiting on a person in the app (sending, posting, going live...): only the ones that are yours to decide. decide_approval approves or rejects one.

Approve or reject one of the actions in list_approvals, as on the Approvals screen: approved, it runs now and the agent hears the result; rejected, the agent is told (with the note, if any).

What the whole agency did since a time (default: the start of today, the agency's own clock): per agent its runs, output actions and last summary, plus what's waiting on a person (approvals, open requests).

What one agent did since a time (default: the start of today): its DM channel posts (each run's write-up and the tools it used), the people's messages to it, and the jobs given to it.

An agent's latest report: the write-up of its last run that made one, and where its reports go (the place its person chose, e.g. a Drive folder).

Every integration (the services agents' tools run on): connected or not, draft or live, its tools. Plus whether code plugins are allowed.

An integration's definition (YAML), and a plugin's code. The shipped ones - brave-search (HTTP), github and gmail (code) - show the format.

Save an integration definition (YAML, kind http | mcp | code) as a draft: it shows in the app's Settings > Connectors to be connected, and no agent can call it until publish_integration. Redrafting a live one keeps the live one working meanwhile. Keys and sign-ins are added by the person in Settings, never here.

Save a code plugin's TypeScript (only if code plugins are allowed in Settings): export default { tools: [{ id, tier, description, input, run: async (args, token, kit) => string }] }. Network only through kit.fetch; it runs sandboxed with the permissions its kind: code definition declares. It runs only once published.

Call one of an integration's tools for real (a draft or a live one), and see what an agent would. A plugin's code can't be tried before it's published.

Make a draft live, and optionally give its tools to an agent. A plugin first gets the independent security review; a serious finding stops it. Done here, it doesn't wait for the app's Approvals.

Try an integration's event (draft or live) without waking anyone: a real poll showing what it finds, and the webhook address to paste into the service.

Subscribe an agent to live events: it wakes when they happen, as well as on its schedule. list_integrations shows each integration's events.

Give an agent tools that a live integration (or the agency's built-ins) provides, each at a tier.

Throw away a draft (a redraft of a live one goes back to the live version), or remove an added integration entirely. Shipped ones can't be removed.