Skip to content

Matrix & Threads

These built-in tools let an agent work inside its current Matrix room and thread: inspect rooms, send voice notes, tag, resolve, move, and summarize threads, stop another agent's reply, make low-level Matrix API calls, and reuse conversation attachments. This page also covers automatic thread summaries.

Tools On This Page

  • matrix_message - Send, read, edit, and react in Matrix conversations.
  • [matrix_room] - Inspect room metadata, available agents, members, thread roots, and room state.
  • [matrix_voice_message] - Generate speech from text and send it as a Matrix voice note.
  • [thread_tags] - Add, remove, and list shared tags on Matrix threads.
  • [thread_resolution] - Resolve or reopen threads in the current room.
  • [thread_snooze] - Snooze a thread until a set time; it returns with a message.
  • [thread_move] - Move a thread from the current room into another room.
  • [thread_summary] - Set or replace a thread's summary.
  • [stop_reply] - Stop the reply another agent or team is writing in the current conversation.
  • [react] - Add an emoji reaction to a message in the current room, and do nothing else.
  • [email_invite] - Invite people to the current room by email, after someone who may invite approves.
  • thread_model - List models or show, switch, and reset the current thread's model override.
  • [matrix_api] - Low-level Matrix event, state, redaction, and search calls with explicit IDs.
  • [matrix_user] - Read Matrix as a personal agent's owner and, when they ask, write as them.
  • attachments - List, inspect, and register attachment IDs for later tool calls.

None of these tools has tool-specific configuration fields except [matrix_voice_message]. Enable them by listing them in an agent's tools, as described in Per-Agent Tool Configuration. Enabling matrix_message also enables attachments and matrix_room.

Tool Runtime Context

Except the reads of [matrix_user], these tools work only while an agent is responding in a Matrix conversation. Unless the call passes explicit IDs, they act on the current room and thread, except [matrix_user], which needs room_id for every action on a room. matrix_message, matrix_voice_message, thread_tags, thread_resolution, thread_snooze, thread_move, and thread_summary accept a reply event ID as thread_id and act on its thread root. thread_tags, thread_resolution, thread_snooze, thread_move, and thread_summary refuse a thread target with Failed to resolve a canonical thread root for the target event. when the agent cannot read the target message or its thread, for example because it cannot decrypt them, and a matrix_api send into such a thread is refused with Failed to resolve threaded Matrix message send target.; target a thread whose messages the agent can read. room_id takes a room ID, alias, or configured room name; matrix_api takes only a room ID. Except [matrix_user], tools that accept room_id can target another room only when the requester has access to the agent and is currently joined to that room. matrix_api is the exception: it defaults room_id to the current room but never infers event IDs, thread IDs, or state keys from the conversation. Attachment IDs (att_*) are limited to the current conversation and IDs registered earlier in the same tool run; see Attachments.

[matrix_room]

matrix_room(action="room-info", room_id=None, limit=None, event_type=None, state_key=None, page_token=None, include_summaries=False, workflow=None) reads room data and never writes. Use matrix_message or matrix_api for writes.

Action Returns
room-info Room name, topic, encryption, member count, join rule, canonical alias, room version, guest access, creator, power-level summary, and the current thread_id, reply_to_event_id, requester_id, and agent_name (the thread is omitted when inspecting another room)
members Joined users with display names, avatar URLs, and power levels
agents Agents that can currently answer this requester in the room, each with name, matrix_user_id, description, and thread_mode (thread or room)
threads Thread-root previews with sender, timestamp, reply count, and latest activity; limit defaults to 20 (range 1-50), and next_token plus has_more support paging through page_token; include_summaries=True adds each thread's current summary (or null) and summary_pinned, at the cost of reading every listed thread; workflow (needs_you, working, later or all) labels each row with its workflow group as MindRoom Chat computes it (done for resolved threads), adds why (approval, question or your_turn) to needs_you rows and back_at (ms) to later rows when known, and keeps only the named group, so a filtered page can hold fewer rows than limit; room_id="all" lists one page of threads from every room the requester is a member of and shares with the agent, each row with its room_id, waiting rows first, without page_token
state With event_type, one state event (state_key defaults to empty); without it, a summary of up to 100 non-member state events

Pass an agents result's name as recipient in matrix_message to address that agent. The list covers conversation targets only; the run_subagent tool describes the caller's allowed subagents. Each agent, requester, and room combination may make 20 calls per 30 seconds.

matrix_room(action="agents")
matrix_room(action="threads", limit=10)
matrix_room(action="threads", page_token="next-page-token")
matrix_room(action="state", event_type="m.room.topic")

[matrix_voice_message]

matrix_voice_message(text, room_id=None, thread_id=None, caption=None, companion_message=None) converts text to speech and sends it as one Matrix voice note. It targets the current room and thread by default; pass thread_id="room" to post at room level. caption sets the audio event's body, and companion_message sends a separate readable text message to the same place. The result includes event_id and, when companion text was sent, companion_event_id. Each agent, requester, and room combination may send six voice messages per 30 seconds.

Field Default Meaning
api_key none Speech API key; when empty, OpenAI models use OPENAI_API_KEY (or OPENAI_API_KEY_FILE, or a stored credential) and OpenRouter models use OPENROUTER_API_KEY
model gpt-realtime-2.1-mini gpt-realtime IDs use the OpenAI Realtime API, other plain IDs an OpenAI-compatible /audio/speech endpoint, and provider-prefixed IDs such as hexgrad/kokoro-82m route through OpenRouter
base_url none Any OpenAI-compatible speech endpoint, such as a local Kokoro server, with model set to one it serves; also settable through the TTS_URL secret
voice alloy Voice name; gpt-realtime models offer alloy, ash, ballad, coral, echo, sage, shimmer, verse, marin, and cedar
response_format opus Format the endpoint returns: aac, flac, mp3, opus, or wav; OpenRouter always uses mp3, and gpt-realtime models ignore it

base_url accepts a bare host, a /v1 URL, or a full /audio/speech URL, which is used as given. A custom non-OpenRouter base_url without api_key never receives your OpenAI key. gpt-realtime models and formats other than opus require ffmpeg and ffprobe on the backend host; opus from a speech endpoint works without them but the voice note then has no duration.

agents:
  assistant:
    tools:
      - matrix_voice_message:
          model: kokoro
          base_url: http://localhost:8880/v1
matrix_voice_message(
    "The build finished successfully.",
    companion_message="The build finished successfully.",
)

[thread_tags]

thread_tags adds, removes, and lists tags that every member sees on a thread, such as on MindRoom Chat thread cards.

  • tag_thread(tag, thread_id=None, room_id=None, note=None, data=None) adds or updates one tag and returns the thread's updated tags.
  • untag_thread(tag, thread_id=None, room_id=None) removes one tag and returns the updated tags.
  • list_thread_tags(thread_id=None, room_id=None, tag=None, include_tag=None, exclude_tag=None, include_untagged=False) lists tags for one thread or the whole room.

Without thread_id, tag_thread() and untag_thread() use the current thread; outside a thread, pass thread_id. Without thread_id, list_thread_tags() lists the current thread, or the whole room when called outside a thread or with room_id.

Tag names that are already valid IDs of up to 50 characters are kept; other input is lowercased and hyphenated into a tag of at most 25 characters. The tag_thread() description shows the agent up to 20 of the room's most-used tags, refreshed daily, so it reuses existing vocabulary. Some tags validate their data: blocked.data.blocked_by must be a list of strings, waiting.data.waiting_on a non-empty string, priority.data.level one of high, medium, or low, and due.data.deadline an ISO-8601 timestamp.

resolved is thread lifecycle state, so tag_thread() and untag_thread() reject it; use [thread_resolution] instead. snoozed is lifecycle state too, and tag_thread() and untag_thread() point to [thread_snooze]. Listing and filtering by resolved still works.

Filters for list_thread_tags():

  • tag keeps only that tag in the output.
  • include_tag returns only threads that have the tag, and exclude_tag returns only threads without it; they can be combined.
  • include_untagged=True lists the whole room, including threads that have no tags, and cannot be combined with thread_id. It reads at most 2,000 thread roots, so check the truncated field before treating the list as complete.
tag_thread("blocked", data={"blocked_by": ["$otherThread"]})
untag_thread("blocked")
list_thread_tags(exclude_tag="resolved", include_untagged=True)  # unresolved threads

Writing a tag requires both the agent's Matrix account and the requesting user to have enough power level to send room state in the target room, and the requesting user must be joined to it.

[thread_resolution]

thread_resolution lets an agent resolve or reopen threads in the current room. The mindroom config init starter gives it to Mind, with a tool approval rule that makes each resolve_thread call wait for the requester's approval. It is not in default tool sets, so other agents cannot resolve threads unless an operator grants it or an agent with self_config adds it to its own tools.

resolve_thread(thread_id=None) adds the resolved state, and reopen_thread(thread_id=None) removes it. Without thread_id, both require an active thread. Pass a thread root or reply event ID to target another thread in the current room, including from the room timeline; an ID that does not resolve to a thread returns an error and changes nothing.

agents:
  triage:
    tools:
      - thread_tags
      - thread_resolution

To close out finished threads, find candidates with list_thread_tags(exclude_tag="resolved", include_untagged=True), check truncated, then call resolve_thread(thread_id=...) for each one.

[thread_snooze]

thread_snooze lets an agent snooze threads in the current room until a set time. The mindroom config init starter gives it to Mind, without an approval rule. It is not in default tool sets, so other agents cannot snooze threads unless an operator grants it or an agent with self_config adds it to its own tools.

snooze_thread(until, note=None, thread_id=None) adds the snoozed state, and unsnooze_thread(thread_id=None) removes it. until is an ISO-8601 datetime with a time part, such as 2026-11-14T09:00:00+01:00; a value without an offset is UTC, and a date alone, an unparsable value, or a time that is not in the future returns an error and changes nothing. note is a reminder the wake message quotes; it is stored unencrypted in room state, even in an encrypted room. unsnooze_thread returns Thread is not snoozed. when the thread has no snooze. Without thread_id, both require an active thread; pass a thread root or reply event ID to target another thread in the current room.

When the time comes, the snoozed state ends and a message in the thread quotes the note. The message mentions the person who set the snooze only when that person or a MindRoom account, such as an agent snoozing it for them, sent the snooze's state event; it starts no agent turn. snoozed is thread lifecycle state, so thread_tags refuses to set or remove it. A snooze set from MindRoom Chat is stored the same way and woken the same way, and resolving a snoozed thread with [thread_resolution] ends its snooze. A snooze that is more than 24 hours past due, for example because MindRoom was down, is ended without a message instead of waking the thread late.

agents:
  triage:
    tools:
      - thread_snooze

[thread_move]

thread_move lets an agent move a thread from the current room into another room, for example to file a conversation under the room of the project it belongs to. It is not in starter configs or default tool sets.

Matrix cannot move messages between rooms, so move_thread(room_id, thread_id=None) copies the thread into a new thread in the target room and copies its tags. The original thread gets a Moved to <link> notice and is marked resolved. Without thread_id, it moves the active thread.

Each agent re-posts its own messages, so the agents in the thread continue the conversation in the new thread with its earlier messages as context. The router re-posts messages from people, and from agents that are not in the target room, prefixed with the author's name. The copies never trigger agent replies.

agents:
  general:
    tools:
      - thread_move

A move is refused when the requester is not joined to the target room, when the router or the agent doing the move is not in it, when the original room is end-to-end encrypted and the target room is not, or when the thread cannot be read in full. Copies have new timestamps and keep only the latest edit of each message. Reactions, notices such as thread summaries, and replies still being written are not copied. Earlier tool-call results, per-thread model choices, agent modes, todos, scheduled tasks, and pending approvals stay with the original thread. Agents count only the people who post after the move, so until two people have posted in the moved thread, an agent that took part may answer untagged messages there.

[thread_summary]

set_thread_summary(summary, thread_id=None, room_id=None, pin=True) posts a new summary notice in the thread, which MindRoom Chat shows as the thread title. summary must be plain text of 1-300 characters after whitespace normalization. Without thread_id, it uses the current thread; outside a thread, pass thread_id.

By default a manual summary pins the thread, so automatic summaries stop updating it. Pass pin=False for a summary that later automatic summaries may replace; this also releases an earlier pin. Editing a summary in MindRoom Chat also pins it when the editor can address an agent in that room. A pinned thread receives no automatic summaries or automatic topic tags; add tags with [thread_tags] instead.

The tool returns an error without posting when it cannot read the thread's complete history, which always happens for threads longer than 2,000 messages or 16 MiB of content.

To retitle many threads, start from matrix_room(action="threads", include_summaries=True): each row has the thread's current summary and summary_pinned, which is true when the title is pinned, so threads can be chosen without reading them before calling set_thread_summary(summary, thread_id=...) for each one. Both fields are omitted for a thread whose complete history cannot be read, the same threads set_thread_summary refuses.

set_thread_summary("Decision: ship the current plan and revisit logs tomorrow.")
set_thread_summary("Routine status update.", pin=False)
set_thread_summary("Summary for the import thread.", thread_id="$threadRoot", room_id="!ops:example.org")

[stop_reply]

stop_agent_reply(agent_name) stops the reply another agent or team is writing in the current room and thread. It is not in starter configs or default tool sets.

The tool reacts ๐Ÿ›‘ on that reply for the user the calling agent is working for, so it works like that user's own Stop Button and needs that user's access to the stopped agent. It returns an error without reacting when the calling agent is not acting for a user, such as in a run another agent started on its own.

agents:
  coordinator:
    tools:
      - stop_reply
stop_agent_reply("researcher")

[react]

react(event_id, emoji) adds an emoji reaction to a message in the current room. Unlike matrix_message, it cannot send, edit, or read messages, so it suits an agent that may only acknowledge, such as a listening agent. It returns an error without reacting when the emoji is blank, longer than 8 characters, or contains a space, or when the event is not in the current room. It shares matrix_message's rate limit for the room (12 actions per 30 seconds), so using both is no way around it.

agents:
  scribe:
    tools:
      - react
react("$event_id", "๐Ÿ‘")

[email_invite]

invite_by_email(email) invites one address to the current room; whether it asks for approval first follows your approval rules, and a require_approval rule for it is recommended. When the person asking may invite, it mails a single-use link, or returns the link to forward by hand when no mail server is configured; otherwise the request waits until someone who may invite asks an agent in the room to "approve the invite for" that address. list_email_invites() lists the room's open invites with their state (waiting or sent), asker, approver and expiry. revoke_email_invite(email) revokes the open invite for an address; its asker, its approver, or anyone who may invite can do so, and an invite already used is reported with the account that used it. No function takes a room, a Matrix ID, or text, so the mail is always the fixed one for the current room. Set-up, the approval rule, and the limits are on Email Invites.

agents:
  host:
    tools:
      - email_invite

[matrix_api]

matrix_api gives exact control over Matrix events and room state when matrix_message is not enough. Grant it only to agents that need raw Matrix access. Every action returns a JSON payload, including errors.

Action Required arguments
send_event event_type, content
get_state event_type, optional state_key
put_state event_type, content, optional state_key
redact event_id, optional reason
get_event event_id
search search_term, optional keys, order_by, limit, next_batch, filter, event_context

room_id defaults to the current room; see Tool Runtime Context for other rooms. dry_run=true validates send_event, put_state, and redact without writing. Writes are logged and limited to 8 units per 60 seconds for each agent, requester, and room, where send_event costs 1 and put_state and redact cost 2. A message sent with send_event for a human requester triggers the agents it mentions as that requester, like an ordinary agent reply.

Write restrictions:

  • m.room.create is always blocked.
  • m.room.power_levels, m.room.encryption, m.room.server_acl, m.room.join_rules, m.room.history_visibility, m.room.guest_access, m.room.member, m.room.canonical_alias, m.room.tombstone, and m.room.third_party_invite are dangerous: put_state needs allow_dangerous=true, and the requesting user (or one of their bridge aliases) must be joined to the room with power level 100.
  • Redacting a state event follows the same rules as writing that state type.
  • The com.mindroom.* and io.mindroom.* namespaces, and MindRoom Chat's chat.mindroom.*, are reserved: no event type in them can be written, and content cannot contain keys in them at any depth.
  • Namespaces a loaded plugin reserves in its manifest are refused the same way; see Reserved namespaces.

search is read-only full-text search in one room. It uses the top-level limit (1-50, default 10), rejects filter.limit, and keys may include content.body, content.name, and content.topic. Set event_context={"include_profile": true} to include sender profiles in the surrounding context.

matrix_api(action="get_event", event_id="$event123")
matrix_api(action="put_state", event_type="com.example.marker", state_key="status", content={"value": "ready"})
matrix_api(action="redact", event_id="$event123", reason="Cleanup")
matrix_api(
    action="search",
    search_term="deployment incident",
    keys=["content.body"],
    event_context={"before_limit": 1, "after_limit": 1, "include_profile": True},
)

[matrix_user]

matrix_user lets a personal agent use Matrix as its owner, with no sign-in: it reads the owner's own rooms and DMs, including rooms the agent is not in, and writes as the owner when they ask. It acts only for the agent's owner, in any turn that runs for them, such as a chat with the agent or one of their scheduled tasks, or, for reads, through the MCP gateway, and refuses, saying why, anyone else, any other agent, and a contact conversation.

matrix_user_read(action, room_id=None, event_id=None, thread_id=None, query=None, page_token=None, limit=None) sends nothing as the owner, and only mark_read changes anything: the owner's own read state.

Action Returns
rooms The owner's rooms, one line each: unread rooms first, with their unread and mention counts and whether the owner marked them unread, then invitations with who sent them, then the rest by name; a DM without a name shows the other person; query keeps rooms whose name contains it, and limit (default 20, at most 200) caps the lines, with left_out counting the rest
messages The newest messages of the room room_id names, oldest first, one line each with its latest edit applied and its file, reactions, and thread replies noted, and texts over 2000 characters cut; limit defaults to 30 (at most 100) and counts reactions and edits too, so a page can show fewer lines, and page_token, the previous result's next_page_token, continues into older messages; with thread_id, that thread's root and newest replies; with event_id, that message and up to half of limit messages on each side
search Messages containing query in all the owner's rooms, or only in room_id, newest first, each line starting with its room; limit defaults to 10 (at most 50), and page_token continues
room The name, topic, encryption, whether it is a DM, the joined member count, and up to limit members (default 50, at most 200) of the room room_id names
people With a full Matrix ID as query, that person's profile; otherwise people the user directory finds, limit defaulting to 10 (at most 50)
download The file, at most 64 MiB, of the message event_id in room_id, as an attachment_id the agent's other tools accept in the current conversation, so not through the MCP gateway
mark_read Marks room_id read up to event_id, or up to its newest message, with a private read receipt that others do not see, and clears the owner's marked-unread flag

Messages in encrypted rooms are not readable: each shows as [encrypted, not readable], several in a row as one line such as [3 encrypted messages, not readable], and search does not find them.

matrix_user_write(action, room_id=None, user_id=None, message=None, event_id=None, thread_id=None, emoji=None, attachment=None, name=None) acts as the owner in any turn that runs for them, such as a chat with the agent, one of their scheduled tasks, a hook or trigger, or a team run, but not through the MCP gateway. Whether a call asks the owner first is decided by the approval rules, as for any tool, so with no rule that requires approval and tool_approval.default: auto_approve, an unattended turn such as a scheduled task writes as the owner too. A deployment that wants a card for every write sets:

tool_approval:
  rules:
    - match: matrix_user_write
      action: require_approval

A script rule can decide per call from the arguments, for example asking for send and letting react through, and an approval the owner gives for a period, on a card or with !auto_approve, covers later calls.

Action Does
send Sends one message into room_id, or into the owner's existing DM with user_id; with none, nothing is sent, and the owner can start one in their Matrix client, or the agent can make a room with create_room, invite them, and send there: the text message, or the file attachment names, an attachment ID of the conversation, so a text and a file are two calls; thread_id sends into that thread, and event_id makes message a reply to that message
react Reacts to the message event_id in room_id with emoji, one emoji of at most 8 characters and without spaces
edit Replaces the text of the owner's own text message event_id in room_id with message; a photo, file, or audio message cannot be edited
redact Deletes the owner's own message or reaction event_id in room_id, with message as the reason
join, leave Joins or leaves room_id
invite Invites user_id into room_id
create_room Creates a private room called name and invites nobody; invite adds people

What it sends shows as the owner's to everyone, but MindRoom never takes it as the owner speaking: it starts no reply, runs no command, and approves or denies nothing, so the agent talks to other agents as itself. Nothing is sent, reacted, or edited into an encrypted room.

To set it up, register an application service on the homeserver whose non-exclusive users namespace covers its people, and give MindRoom its as_token as MATRIX_USER_APPSERVICE_TOKEN, or the path of a file holding it as MATRIX_USER_APPSERVICE_TOKEN_FILE. That token can act as every account the users pattern covers, administrators included. Without it, the toolkit answers matrix_user is not set up: the runtime has no MATRIX_USER_APPSERVICE_TOKEN.

# The homeserver's registration file; MindRoom needs only as_token.
id: mindroom-user
url: null
as_token: <a long random secret>
hs_token: <another long random secret>
sender_localpart: mindroom-user
namespaces:
  users:
    - exclusive: false
      regex: "@.*:example.com"
personal_agents:
  mind:
    agent:
      tools:
        - matrix_user

Automatic Thread Summaries

MindRoom starts a background title for a new thread from its first prompt, using the transcription for voice messages, without waiting for the agent's reply. It only does so when the first threshold below is 1 or 2, so the first reply would already title the thread. This provisional title does not change the summary or topic-tag refresh schedule below. MindRoom checks a thread's title after a response brings it to defaults.thread_summary_first_threshold messages (default 1), then again after every defaults.thread_summary_subsequent_interval further messages (default 10), and posts a summary notice when the title changes. Threads that are pinned with [thread_summary] or marked resolved are skipped, as are threads whose full history cannot be read, which always includes threads longer than 2,000 messages or 16 MiB of content. For threads with more than 50 messages, the summary model sees only the first three and last three. A new automatic title is one emoji and at most six words, such as ๐Ÿงช Attachment cache live test: MindRoom sends a longer answer back to the model with the reason, up to 3 attempts in all, and posts no title if every attempt is too long. The prompt asks for the emoji, but a title without one is still posted. The emoji and dashes are not words but count toward the 80 characters; only the (forked) marker MindRoom adds to a fork's title is outside both limits. Text without spaces, such as Chinese or Japanese, is bounded only by the 80 characters. A check shows the model the current title, and the model keeps it unless the thread's main topic has clearly changed: a kept title usually posts nothing, and the next check is a full interval later. Two checks re-post the unchanged title once: the first check after the first reply, and the check that adds tags. After a restart, the next check may come early. A title longer than six words, such as one from an older version, is not offered to keep, so the next check asks for a new title; a retitle, such as after a call's notes, always does too.

The summary uses the first match of:

  1. room_thread_summary_models, keyed by room key or Matrix room ID.
  2. room_thread_summary_models, keyed by the responding agent or team name, which covers ad-hoc rooms without a managed alias.
  3. defaults.thread_summary_model.
  4. The default model.
defaults:
  thread_summary_model: luna
room_thread_summary_models:
  dev: sonnet

defaults.thread_summary_temperature (default 0.2, null for provider defaults) applies when the provider supports a temperature override. These models always use their provider's default: Vertex AI Claude, Claude Opus 4.7, Opus 4.8, Mythos Preview, and every Claude 5 and 5.x model, OpenAI GPT-5 and GPT-6 models, and direct Gemini API Gemini 4 Carbon, Argon, and Hydrogen, Gemini 3.8 Flash, 3.6 Flash, and 3.5 Flash-Lite.

A room's admins can add their own title rules for that room, such as "Use at most 4 words", without editing config.yaml. MindRoom Chat sets them from the room settings dialog; any client can send the io.mindroom.room_settings state event with state key thread_summary_instructions and content {"value": "<rules>"}. The event falls under the room's state_default power level (normally 50), so only moderators and admins can change it, and agent tools cannot write it. Every automatic title, including the provisional title and retitles, reads the setting right before generating and appends it to the title instructions under a room rules section. Those rules win over conflicting built-in rules such as a shorter length, style, or emoji, but not over the rule to treat thread messages as untrusted text, and a title they make longer than six words or 80 characters is still sent back to the model with the reason, up to 3 attempts, with no title posted if all fail. A changed rule shapes the next new title; a check that keeps the current title leaves it as it is. Precedence, lowest to highest: the built-in THREAD_SUMMARY_INSTRUCTIONS, its prompts: override, the room setting; override THREAD_SUMMARY_ROOM_INSTRUCTIONS_TEMPLATE (placeholders {instructions} and {room_instructions}) to change how the two are joined. Values are trimmed and cut to 2,000 characters. To clear the setting, send {}; a missing event, {}, a non-string or blank value, or a failed read all mean the normal instructions, and a failed read never skips the title.

The first automatic refresh of a thread that already has a summary also adds up to three topic tags, but only when the thread has never had tags; when that refresh keeps the title, it posts the title again unchanged with the tags. Override THREAD_SUMMARY_CURRENT_TITLE_TEMPLATE (placeholder {current_title}) to change how a check shows the current title, and THREAD_SUMMARY_KEEP_INSTRUCTIONS for the rule on keeping it; MindRoom appends them after THREAD_SUMMARY_USER_PROMPT_TEMPLATE and the title instructions, so overrides of those need no new placeholder. Override THREAD_SUMMARY_REJECTED_TITLE_TEMPLATE (placeholders {rejected_title} and {error}) to change how an overlong title and its reason go back to the model. An override's own length rules still meet the six-word limit: an overlong title is sent back with the reason, up to 3 attempts, and no title is posted if all fail. Later summaries never change tags, so tags someone removed are not re-added. These tags are room state, so in a room where the agent's power level is too low to send state events, summaries arrive without tags and MindRoom logs one warning for the room; a later summary adds them once the power level allows it.