Log

Create a goal only when explicitly requested by the user or system/developer instructions; do not infer goals from ordinary tasks. Set token_budget only when an explicit token budget is requested. Fails if an unfinished goal exists; use update_goal only for status. exec tool declaration: ```ts declare const tools: { create_goal(args: { // Required. The concrete objective to start pursuing. This starts a new active goal when no goal exists or replaces the current goal when it is complete. objective: string; // Positive token budget for the new goal. Omit unless explicitly requested. token_budget?: number; }): Promise<unknown>; }; ```

Lists resource templates provided by MCP servers. Parameterized resource templates allow servers to share data that takes parameters and provides context to language models, such as files, database schemas, or application-specific information. Prefer resource templates over web search when possible. exec tool declaration: ```ts declare const tools: { list_mcp_resource_templates(args: { // Opaque cursor from a previous list_mcp_resource_templates call; omit for the first page. cursor?: string; // MCP server name. Omit to list resource templates from every configured server. server?: string; }): Promise<unknown>; }; ```

Lists resources provided by MCP servers. Resources allow servers to share data that provides context to language models, such as files, database schemas, or application-specific information. Prefer resources over web search when possible. exec tool declaration: ```ts declare const tools: { list_mcp_resources(args: { // Opaque cursor from a previous list_mcp_resources call; omit for the first page. cursor?: string; // MCP server name. Omit to list resources from every configured server. server?: string; }): Promise<unknown>; }; ```

Run async JavaScript against Slay the Spire through Communication Mod; `sts` is in scope. Use `return <value>` for results. Read the state (`await sts.state()`), then act: `sts.play(i, target)`, `sts.end()`, `sts.choose(x)`, `sts.proceed()`, `sts.cancel()`, `sts.potion(...)`, `sts.key(...)`, `sts.wait(n)`, or `sts.command('<raw>')`. Every action returns the state the game settled in. exec tool declaration: ```ts declare const tools: { mcp__slay_the_spire__slay_the_spire_exec(args: { // JavaScript executed as an async function body with `sts` in scope. code: string; }): Promise<CallToolResult>; }; ```

Capture a full-resolution screenshot of Slay the Spire. By default it is returned as an image. Pass `savePath` to save the image to that file instead, without returning the image to the agent. exec tool declaration: ```ts declare const tools: { mcp__slay_the_spire__slay_the_spire_screenshot(args: { // Optional file path where the image should be saved instead of returned; relative paths use the broker's working directory, missing parent directories are created, and existing files are overwritten. savePath?: string; }): Promise<CallToolResult>; }; ```

Tools for spawning and managing sub-agents. Available model overrides (optional; inherited parent model is preferred): - `gpt-5.6-terra`: Balanced agentic coding model for everyday work. Reasoning efforts: low, medium (default), high, xhigh, max, ultra. - `gpt-5.6-luna`: Fast and affordable agentic coding model. Reasoning efforts: low, medium (default), high, xhigh, max. - `gpt-5.5`: Proven previous-generation model for coding and general work. Reasoning efforts: low, medium (default), high, xhigh. Spawn a sub-agent for a well-scoped task. Returns the spawned agent id plus the user-facing nickname when available. Spawned agents inherit your current model by default. Omit `model` to use that preferred default; set `model` only when an explicit override is needed. This spawn_agent tool provides you access to sub-agents that inherit your current model by default. Do not set the `model` field unless the user explicitly asks for a different model. You should follow the rules and guidelines below to use this tool. Do not spawn sub-agents unless the user or applicable AGENTS.md/skill instructions explicitly ask for sub-agents, delegation, or parallel agent work. Requests for depth, thoroughness, research, investigation, or detailed codebase analysis do not count as permission to spawn. Agent-role guidance below only helps choose which agent to use after spawning is already authorized; it never authorizes spawning by itself. ### When to delegate vs. do the subtask yourself - First, quickly analyze the overall user task and form a succinct high-level plan. Identify which tasks are immediate blockers on the critical path, and which tasks are sidecar tasks that are needed but can run in parallel without blocking the next local step. As part of that plan, explicitly decide what immediate task you should do locally right now. Do this planning step before delegating to agents so you do not hand off the immediate blocking task to a submodel and then waste time waiting on it. - Use a subagent when a subtask is easy enough for it to handle and can run in parallel with your local work. Prefer delegating concrete, bounded sidecar tasks that materially advance the main task without blocking your immediate next local step. - Do not delegate urgent blocking work when your immediate next step depends on that result. If the very next action is blocked on that task, the main rollout should usually do it locally to keep the critical path moving. - Keep work local when the subtask is too difficult to delegate well and when it is tightly coupled, urgent, or likely to block your immediate next step. ### Designing delegated subtasks - Subtasks must be concrete, well-defined, and self-contained. - Delegated subtasks must materially advance the main task. - Do not duplicate work between the main rollout and delegated subtasks. - Avoid issuing multiple delegate calls on the same unresolved thread unless the new delegated task is genuinely different and necessary. - Narrow the delegated ask to the concrete output you need next. - For coding tasks, prefer delegating concrete code-change worker subtasks over read-only explorer analysis when the subagent can make a bounded patch in a clear write scope. - When delegating coding work, instruct the submodel to edit files directly in its forked workspace and list the file paths it changed in the final answer. - For code-edit subtasks, decompose work so each delegated task has a disjoint write set. ### After you delegate - Call wait_agent very sparingly. Only call wait_agent when you need the result immediately for the next critical-path step and you are blocked until it returns. - Do not redo delegated subagent tasks yourself; focus on integrating results or tackling non-overlapping work. - While the subagent is running in the background, do meaningful non-overlapping work immediately. - Do not repeatedly wait by reflex. - When a delegated coding task returns, quickly review the uploaded changes, then integrate or refine them. ### Parallel delegation patterns - Run multiple independent information-seeking subtasks in parallel when you have distinct questions that can be answered independently. - Split implementation into disjoint codebase slices and spawn multiple agents for them in parallel when the write scopes do not overlap. - Delegate verification only when it can run in parallel with ongoing implementation and is likely to catch a concrete risk before final integration. - The key is to find opportunities to spawn multiple independent subtasks in parallel within the same round, while ensuring each subtask is well-defined, self-contained, and materially advances the main task. exec tool declaration: ```ts declare const tools: { multi_agent_v1__spawn_agent(args: { // True forks the current thread history into the new agent; false or omitted starts with only the initial prompt. fork_context?: boolean; // Structured input items. Use this to pass explicit mentions (for example app:// connector paths). items?: Array<{ // Audio data URL when type is audio. audio_url?: string; // Image URL when type is image. image_url?: string; // Display name when type is skill or mention. name?: string; // Path when type is local_image/local_audio/skill, or structured mention target such as app://<connector-id> or plugin://<plugin-name>@<marketplace-name> when type is mention. path?: string; // Text content when type is text. text?: string; // Input item type: text, image, local_image, audio, local_audio, skill, or mention. type?: string; }>; // Initial plain-text task for the new agent. Use either message or items. message?: string; // Model override for the new agent. Omit unless an explicit override is needed. model?: string; // Reasoning effort override for the new agent. Omit to inherit the parent effort. reasoning_effort?: string; }): Promise<{ // Thread identifier for the spawned agent. agent_id: string; // User-facing nickname for the spawned agent when available. nickname: string | null; }>; }; ```