Manually add a learning/insight to an agent. High-confidence learnings are injected into the agent's system prompt.

Add an event trigger or schedule to an agent. Event triggers fire when a matching event occurs. Schedules run periodically. A schedule's runs work for project; without it they inherit the project of an office that serves exactly one, and otherwise run outside any project (and cannot draft from a project's accounts).

Ask the chief about a doubt you can't resolve alone: unclear requirements, priorities, or a decision you are not authorized to make. Give 2 to 4 concrete options, your preferred one first. The chief answers or escalates it to the human. Don't wait idle: keep working on what doesn't depend on it. The answer comes back as a new run or an inbox message. Never re-ask a question that was already answered.

Call a group meeting with other agents. You (the caller) become the moderator. The meeting runs N structured rounds (default 2, capped at 20) where each attendee gives input, then you synthesize into decisions and action items. Use this when you need collaborative input from multiple agents before proceeding.

Create a declarative chain between two agents. When the source agent completes, the target agent is automatically triggered.

Create a new autonomous agent definition with system prompt, goal template, tool permissions, and LLM config

Chief only. Set how a kind of question (category) is handled in an office: off, suggest (show what past decisions suggest), or auto (a precedent answers it alone while its measured precision holds). Only turn on auto when the operator asked for it.

Read-only. Per kind of question (category) in an office: the policy (off / suggest / auto), and how often the operator chose what past decisions suggested — the measured precision a category needs before a precedent may answer it alone.

Soft-delete an agent (sets active=0, preserves history)

View the full office directory — all departments (flows) with their agents, roles, capabilities, and connections. Use this to find agents you can request help from or delegate work to.

Read-only. The environment problems open in your office, since when, and who is waiting on each.

Report that something in your office's environment blocks your work (DEV down, a missing credential, a broken deploy). Use the same short key every time for the same problem (dev-e2e, credential-dev-patient-jwt). If it is already open you just join it — nobody is asked again. You get a letter when it is fixed: park the work until then.

Close an environment problem of your office that is fixed. Everyone who joined it gets a letter to resume.

Finalize an Agent Factory draft: validate the proposed tools against the real catalog, resolve/create the target office, guard against duplicates, and create the agent INACTIVE (active=0) for human review. Returns the activation command. Use AFTER you've researched the domain, synthesized the system prompt, and picked tools via kernel_tool_search.

Rate an agent run and provide feedback. The agent learns from feedback to improve future runs.

Create a new flow (department / office). Returns the new flow id, which you must pass to subsequent kernel_agents_create calls so the agents show up under this office in the 3D view.

List active flows (offices / departments). Use this before creating a new one to avoid duplicates.

Promote an office (flow) to a host git repo all its agents work in, or revert it. Pass an absolute path to promote; omit/empty path to revert to the kernel workspace home. Agents without their own cwd_path override will use this directory as cwd.

List the procedural skills attached to an agent, with descriptions and token estimates.

List past runs for an agent

Read an agent's office inbox (messages from colleagues). Defaults to the caller's own inbox and shows unread items only. Useful for the dashboard or to check what's pending before a run.

Acknowledge office-inbox letters you have finished handling. Unacknowledged letters are handed to you again by the inbox sweeper (up to 3 times), so ack every letter you completed.

List all agent definitions, optionally filtered by active status

List active conversation subscriptions for an agent. Useful before subscribing (to avoid duplicates) or to audit what conversations an agent is watching.

List event triggers, schedules, and chains for an agent

Read an agent's conversational memory — recent interactions with humans and other agents. Use this to check what another agent has been working on or said recently.

Leave an async message in another agent's inbox. Works ACROSS offices — every agent can reach every other agent. The recipient does NOT run immediately — the message appears as a 'PENDING REQUESTS FROM COLLEAGUES' block in their system prompt the next time they run, then is marked read. Use this for blockers, clarifications and hand-backs between agents. For a doubt that needs a decision from above use kernel_agents_ask_supervisor. For blocking one-shot questions use kernel_agents_invoke; for group deliberation use kernel_agents_call_meeting. To continue a thread, pass in_reply_to_message_id (the conversation-message id of the turn you are replying to) or an explicit conversation_id. To signal disagreement with something the recipient (or a peer) said, set role: "counter" — 2+ counters from different agents on the same conversation auto-opens a debate.

Read-only. Everything about an escalated question: the question, the chief's reason, the 4 options, the full context, and the asking agent's run (its goal and steps up to the question).

Chief only. Answer a question in triage: pick one of its options by 0-based selected_index, or write text when none fits. The asking agent gets the answer and resumes.

Chief only. Hand a question in triage to the human, with a one-line reason they will read. Use for product or business decisions, money, irreversible actions, or anything you are not sure about.

Chief only. List the office agents' questions waiting for your triage, with their 4 options.

Remove an event trigger or schedule from an agent

Resume an interrupted agent run from its last checkpoint (native agents only). Use it on a run the kernel failed with 'resumable with kernel_agents_resume'. Tool calls whose outcome was lost are not repeated — the agent is told their result is unknown.

Manually trigger an agent run with a specific goal. Returns the run result.

Attach (or replace) the procedural skills loaded by an agent. Each slug must reference an installed extension with type='skill'. Pass an empty array to detach all.

Get performance stats for an agent: success rate, avg tokens, top tools, common errors, learnings

Get the status and step-by-step log of an agent run

Read-only. Everything asked and decided about an issue and all its parts (web#2653 covers web#2653:a-b…), oldest first: who asked, the answer, who decided it and through what channel, and which environment problems were open at the time. Read it before asking about a subject again.

Subscribe an agent to a conversation. Once subscribed, every new turn in that conversation wakes the agent with a run (mode='responder') so it can read and reply without being explicitly invoked. Use this to keep an agent engaged in a thread after invoke/post/meeting hands the topic over. Idempotent — re-subscribing updates the mode/filter. Defaults: subscribe yourself unless agent_id is set.

Remove a chain between two agents

Cancel a conversation subscription so the agent stops being woken by new turns. Defaults to the caller unless agent_id is supplied.

Update an agent definition (name, prompt, tools, config, active status)

Declare what an office's home folder must contain and prepare it now: git repos to clone (at a branch), files to seed, MCP servers and skills for every claude_code agent working in the home. Replaces the previous spec. Existing checkouts are never re-cloned or reset; seeded files only replace an existing one when overwrite is true. Runs of the office wait for the home to be ready and fail with the reason when it can't be prepared.

Show an office's declarative workspace spec and how its last preparation went.

Return this kernel's Ed25519 attestation identity (server_id) and whether attestation is currently enabled. Clients pin this fingerprint and verify every receipt against it.

Verify a previously-issued attestation receipt against its embedded server_id. Stateless verification — does not check whether you actually trust that signing identity. Wire-compatible with the Rust mtw-attest crate.

Verify a plan receipt + its child receipts as one chained audit. Returns valid only when (1) the plan receipt's own signature checks out, (2) every child verifies, and (3) the merkle root of the children matches the one inside the plan receipt. Stateless — works on chains from any peer.

Recent tool calls that wrote something, newest first — by agent, run or tool — with the ids each touched.

Token consumption and cost analysis. Shows which agents burn the most tokens, failure rates, and wasted spend. Critical for budget monitoring.

Query the agent event log for security analysis. Shows agent activity, errors, tool calls, token consumption, and failure patterns.

Who changed this? Every tool call that wrote and named or returned this id (a task, contact, note, fact…): the agent and run or the MCP client that made it, the tool, when, whether it worked, and its arguments in short.

What do I know about X? Searches every memory at once — indexed tasks, notes, contacts and mail (brain), past chat messages, what agents have learned, and the people, tasks, mail, events and products in the graph — by meaning and by words, merges the findings into one ranked list, and shows what each result is connected to. Use it before answering a question about a person, project or topic.

Maintenance: pull every learned weight a fraction back toward the 1.0 baseline so stale boosts/penalties fade. Run periodically.

Record a usage signal for a recalled item to teach the brain. open/correct promote it, ignore demotes it. This is the autoaprendizaje loop — future recalls rank adapted to your behaviour.

Index (or incrementally refresh) module rows into the unified semantic space. Only rows changed since the last run are touched (watermark). Pass kinds to backfill one module at a time. Embeds row text, so run it deliberately when the embeddings backend is healthy.

Unified semantic recall across ALL modules — tasks, notes, contacts, communications, reminders, calendar events — in one ranked result. Use this to surface everything related to a topic regardless of which module it lives in. Ranking blends embedding similarity with a learned per-item weight that adapts to how you use results.

Coverage of the unified space: total items, count per kind, and per-source watermarks.

Run analytics on the concept graph. Shows top concepts by importance and community structure.

Archive a chat episode. In future phases, this also generates a summary embedding.

List extracted concepts from chat conversations, ordered by gravity (cross-conversation importance).

Preview the cognitive context that would be retrieved for a query. Useful for debugging the retrieval pipeline.

Get message history for a chat episode.

List chat episodes, optionally filtered by status.

Send a message in a chat episode and receive the LLM response. The system automatically retrieves relevant context from memory (when available).

View detected temporal and behavioral patterns from chat conversations.

Reinforce a memory node manually, boosting its strength against decay. Use this to mark a memory as important.

Full-text search across all chat messages. Returns matching messages with their episode context.

Start a new chat episode (conversation). Returns the episode ID to use with kernel_chat_message.

Read a source file from the project (read-only). Restricted to project src — cannot read .env, credentials, node_modules, or data.

Run a small JS script that can call other kernel tools via tool(name, args). Use this to compose multiple tool calls in ONE inference round (e.g. list-then-filter, create-then-run). Sandbox: no FS, no network, no require, 5s default wall-clock. Available helpers: tool(name, args) (async), log(msg), input (the vars object). Example: const r = await tool("kernel_tasks_list", {}); return r.tasks.length.

Search for a pattern in the project source code (grep). Returns matching lines with file paths. Restricted to src/ directory.

List all known configurable settings with their descriptions, types, and categories. Use this to discover what can be configured.

Get the current value of a specific configuration setting by its env-var key (e.g. ANTHROPIC_API_KEY, LIFE_CITY, CHAT_DEFAULT_PROVIDER). Sensitive values are masked.

List all kernel configuration settings, optionally filtered by category. Sensitive values (API keys, tokens) are automatically masked.

Set a configuration value. Changes take effect immediately (no restart needed) and are persisted to the .env file. Examples: set LIFE_CITY to 'Berlin', set CHAT_DEFAULT_PROVIDER to 'openai', set PROACTIVE_MORNING_TIME to '08:00'.

Set multiple configuration values at once. Useful when applying a group of related settings, e.g. changing location (latitude + longitude + city + timezone).

Evening review: what was completed today, what's pending, and tasks for tomorrow.

Morning briefing: today's tasks, overdue items, upcoming deadlines, contacts needing follow-up. Your daily overview.

Weekly planning summary: tasks completed this week, open items, upcoming deadlines, contact activity.

Activate an installed-but-idle extension (those with manifest.requires_activation=true). Equivalent to enable() for that subset — exists as a separate tool so the consent step is auditable.

Disable an installed extension by id.

Enable an installed extension by id.

Install an extension from a local .kernl bundle path.

List installed extensions, optionally filtering by type or status.

Get the install receipt for an extension — proves WHO installed it WHEN and from WHERE, with the kernel's Ed25519 signature. Includes a download watermark when fetched from a watermarking marketplace provider.

Remove an extension (deletes files + row).

Upgrade an installed extension in place from a local .kernl bundle path.

The graph as it stood at a moment: every fact about a person or thing (subject ref or name) at at, each one classified by both timelines — known (true then and Kernl knew it), stale (Kernl believed it then but it was no longer true, or was a mistake) or unknown (true then, but Kernl had not learned it yet) — with the agent that wrote it and what it replaced. One traversal of the graph.

Record a fact about a person, thing or the user — subject, predicate, value — with when it became true. A new value for the same subject and predicate ends the old one (mode change) or replaces it as a mistake (mode correction); the history is kept, so the memory does not hold two contradicting answers. Saying the same thing again changes nothing.

Why did Kernl (or an agent) act that way? Give the person or thing (subject ref or name) and the moment of the decision — at, or action_ref, the id of what the action produced or touched (an email, a task…). Returns what Kernl believed then against what is now known to have been true then, fact by fact, who wrote each belief and from what source, and a verdict: consistent, late_information (the world changed but Kernl learned it after the decision) or wrong_belief (the stored fact was later corrected as a mistake).

Facts that are true now — or were true at as_of, or as Kernl believed them at known_at. history lists every value ever recorded with when it held and whether it was corrected.

A fact no longer holds (how=ended, from at) or never did (how=wrong). It stays in the history.

Graph analytics over the labels you name (and, optionally, only some relationship types): pagerank (who is central), communities (Louvain groups), components (what is connected at all), betweenness (who bridges groups). The result is written on each node as pageRank (pagerank), communityId (communities), componentId (components), betweenness (betweenness) — use it afterwards in kernel_graph_query, e.g. ORDER BY p.pageRank DESC. Runs on Graph Data Science when the graph has it or GDS_REMOTE_URI points at one (only numbered nodes and edges are sent), otherwise in the kernel, up to 200000 nodes.

Ask Kernl's graph a question in plain words ("which people did I email most last month?", "what tasks depend on the report?"). It writes a read-only query from the graph's schema, runs it, fixes it from its own errors, and returns the rows with the query it used.

Run one READ-ONLY Cypher query on Kernl's graph and get rows back. It is checked before it runs: no writing, only db.* read procedures, bounded variable-length paths (at most 6 hops), connected patterns, and labels and relationship types that exist (wrong ones come back with suggestions). Rows are capped by limit.

What Kernl's graph holds: node labels with counts and properties, which relationships connect which labels, and the vector and full-text search indexes. Read it before kernel_graph_query.

Run Cypher — reads AND writes — in your own private, in-memory scratch graph: a working space for plans, dependency maps or a slice of the main graph you want to reshape (see kernel_graph_slice). It belongs to your run, nobody else sees it, and it is wiped when the run ends or after 30 idle minutes. At most 20000 nodes; no LOAD CSV, no apoc/gds/dbms. The main graph is never touched.

Wipe your scratch graph now (it also goes when your run ends).

Take a slice of Kernl's main graph with a READ-ONLY query that returns nodes, relationships or paths (e.g. MATCH p = (:Person {name: $n})-[*1..2]-() RETURN p), checked like kernel_graph_query. into: "scratch" (default) copies it into your scratch graph, keeping labels and properties, with _src set to the original's element id; into: "json" returns it as nodes and relationships, for a sandboxed agent or a file. Embeddings are left out.

Chief only. File a bug in Kernl itself — its code or behaviour — for Kernl's developers. Use it when a failure is Kernl's fault: a wrong result, a missing event, a crash, a tool that does not do what it says. Do NOT use it for an agent hitting its limits (steps, tokens, time), a provider outage or rate limit, expired auth, or an agent's prompt: those are fixed by the operator, not by changing Kernl. Give a precise title, the area of Kernl you believe is at fault, and your diagnosis with evidence. The report stays local until the operator publishes it.

List Kernl's own bug reports (filed by the chief or the operator), newest activity first.

Browse the marketplace: list extensions, agents, flows, themes, and templates. Filter by type, category, or search query.

Browse the unified marketplace catalog (skills, plugins, modules, offices, themes, channels, etc.). Merges every catalog provider with installed status.

Install a catalog item by id or slug. Routes through ExtensionService — works for skills, plugins, modules, offices, themes, etc.

List configured catalog providers (bundled, remote, git, ...).

Uninstall an installed extension by id or slug. Removes the install dir and the row in installed_extensions.

Export a marketplace item as a JSON package for sharing.

Get detailed information about a marketplace item by slug or ID.

Import a marketplace package from JSON. Supports agents, flows, themes, templates.

Install a marketplace item (extension, agent, flow, theme, or template).

Add a review for a marketplace item (1-5 stars).

Get marketplace statistics: item counts by type, install stats, ratings.

Manage themes: activate, deactivate, or preview a theme.

Uninstall a marketplace item.

Top-N tools by accumulated dollar cost. Sourced from rolling p50 stats the cost router maintains across runs. Returns enabled=false when the cost router isn't wired in.

Server-initiated elicitation demo. Asks the connected client to display a yes/no form and echoes the user's choice. Returns action: "unsupported" (with a reason) when the client didn't declare the elicitation capability — every real tool that uses elicitation must handle that branch explicitly.

Render a card as an MCP-application UI surface. Returns both a plaintext summary (for CLI / legacy clients) and an HTML body (for web-based clients that opt into the ui content type — Claude Desktop, ChatGPT, web harnesses). Use this as a template for any domain tool that wants to ship a real surface instead of pasting markdown — wire uiResult(...) from core/helpers.ts.

Apply ONE model migration: replace a gone model with a new one in either a global config key or a per-agent model_chain. Exactly one of configKey / agentId must be given. This is the gated action behind the discovery cron's suggestions — nothing changes until you call it.

List LLM models discovered per provider by the model-discovery cron. Filter by provider slug and/or status (available | gone). Shows when each model was first/last seen.

List configured model references (global config + per-agent model_chain) that point at a model the discovery cron has marked 'gone' upstream — these would 404/403 mid-run. Each entry includes a suggested successor. Read-only: apply with kernel_models_apply_migration.

Create or refresh a whole office (department) in one declarative call: flow + agents + optional chains, cron and home repo. Agents get smart defaults — with repo set they become claude_code executors with native FS tools jailed to that cwd. Idempotent (flow matches by name, agents by slug). The office appears in the 3D agents-flow view immediately.

Export what an office's agents learned (their active, general learnings above a confidence floor) as a knowledge pack: JSON or Markdown, sorted so exporting again gives a clean git diff. Emails, phone numbers, tokens and home paths are blanked unless redact=false. Returns the file's content.

Bring a knowledge pack (the JSON or Markdown that kernel_office_pack_export makes) into an office, for review. Lessons are matched to the office's agents by name (or by role when one agent has it; agent_map overrides), compared with what they already know, and staged — none reaches an agent until accepted with kernel_office_pack_review. Accepted lessons start at confidence 0.6 at most.

Review staged pack lessons. With only import_id it lists them; accept and reject take item ids or "all" (every pending one). Without import_id it lists the imports, with how many lessons still wait. Accepting makes the lesson an ordinary learning of its agent.

List outbox drafts (default: pending). Approving happens only in the dashboard.

Propose something that leaves Kernl (a post, an email, a message, a social-network post) as a DRAFT for the user to approve. Inside a project run the account must be linked to that project. Nothing is published until a human approves it. Social network post or reply: channel "social_post", account_ref "social:self", payload { text: string, reply_to?: string (post id), forum_id?: string, tags?: string[] }.

Append one event to a collection of YOUR office's panel (e.g. a state change for the office timeline). The key is generated.

Create or replace one record in a collection of YOUR office's panel (shown to the operator in the office panel). Use a stable key (e.g. the issue key).

Known places, newest first. missing: true lists items that name a place but have no coordinates yet.

What is near a place: events, trips, hotels and travel activities within a radius, nearest first, with the distance in km. where is coordinates ("-34.60, -58.38"), a map link, the name or address of a known place, or — when the geocoder is on — any address. Items only count once they have coordinates (from a map link, set by hand, or geocoded); kernel_places_list with missing=true shows the rest.

Search businesses on Google Maps by kind and place (e.g. query 'clínicas', location 'Córdoba, Argentina'). Returns name, address, phone, website, rating and a Maps link. Read-only; up to 60 results.

Set where something is, by hand. For an item: kind + ref_id (an event, trip, accommodation or activity id). For a place of your own (home, office, a gym): kind 'manual' with a name. Takes lat/lng or a map link; a hand-set place is never overwritten by a sync.

Re-read events and travel for places, take coordinates from their map links and — when the geocoder is on — look up up to geocode addresses that still have none.

Run a plan that previously passed kernel_plan_validate. When the plan touches non-reversible tools, the caller MUST either pass a matching approval_token (from validate) or set prompt_user: true to drive an interactive elicitation. Returns one outcome per node with status, duration, and the per-call receipt when attestation is on.

Validate + simulate a plan (DAG of tool calls). Pure: nothing executes. Returns issues (cycles, dangling deps, unknown tools), estimated_cost (sum of per-node p50s, latency = critical path), side_effects_preview, and requires_approval (true when any node calls a non-reversible tool). Pair with kernel_plan_execute.

Make an office serve a project (or pause/update its settings for it).

Create a project with its brief (value_prop and audience are required).

Show one project: brief, linked resources and the offices that serve it.

Link an existing resource (social/email account, repo, task project, workspace, GitHub or GitLab connection) to a project. A GitHub/GitLab connection linked to a project is reserved for it: its repos use that one, and no other project's repo can.

List projects (products/businesses offices work for) with status, connector state and pending drafts.

Pull the project's connector snapshot now (institutions, waitlist).

Summarize a large source (a kernel tool's output or an inline list) WITHOUT loading the raw rows into your context. Ranks to top-k (when query set), chunks, runs a bounded map-reduce with concurrency + cooldown caps, and returns a grounded digest with citations. Use this instead of listing a big inventory and summarizing it yourself.

Load the full body of a procedural skill the agent has attached. Call this when a user request matches a skill listed in the system_prompt's 'Available skills' section, to read the step-by-step playbook before acting.

List the paid extensions available in the Kernl store and show which ones your current license already unlocks. Read-only.

Download and install a paid extension from the Kernl store. Requires a license that includes the extension; the license authenticates the download. Installs the signed .kernl and activates it if entitled.

Check the Kernl store for newer versions of your installed, licensed extensions and apply them in place. Only touches extensions you've already installed and your license covers — never installs anything new. Free (no license) is a no-op. Manual trigger; nothing runs automatically.

One-call snapshot of your day, returned as TEXT + structured JSON + an HTML 'ui' block. Aggregates: today's events, overdue+due-today tasks, pending email drafts, open trades and active session PnL. Capable clients (Claude Desktop, web harnesses) render the HTML card; CLI clients see the markdown fallback. Use this whenever the agent or human asks 'what does today look like'.

Fetch the full input/output schema for a tool by name. Use after kernel_tool_search to load only the schemas you'll actually call. Returns the same shape that tools/list would emit for this single tool — minus the host function: this is purely metadata.

Search the kernel tool catalog by free-text query. Returns ranked matches (name + description + tags + score) without dragging their full input schemas into the context. Pair with kernel_tool_describe to fetch one tool's full schema on demand. Replaces the antipattern of dumping every tool into the context window.