Verity: three AI agents look into a Discord report, a human makes the call

ace — Fri, 06 Nov 2026 19:20:40 +0000

TL;DR: Verity is an open-source Discord moderation assistant. When a member reports a message, three agents work on it one after another in a private Switch room: one triages it, one investigates the evidence, and one recommends an action. A human moderator reviews the findings and decides. The agents never get ban permissions.

If you have moderated a Discord with thousands of active members, you know the routine. The queue fills up with petty arguments, screenshots with no context and long complaints. Moderators scroll back through hundreds of messages to find out who started it, whether this person has done it before, and which rule applies. By the time someone acts, they are tired and the member who reported it has waited a long time.

I built Verity for the Flip the Switch hackathon to do that reading, so the moderator can spend their time on the decision.

Why not just use an auto-mod bot?

Most automated moderation fails in one of two ways:

Too strict. It matches a word, misses the joke, and bans a real member.
Too lazy. It dumps raw logs on the moderator and calls that help.

I wanted something in between, with three steps:

Triage: which rule was broken, how urgent is it, and what information is missing?
Investigation: what actually happened, based on timestamps, the messages before the incident, and the uploaded proof?
Advice: given the server's rules and the member's history, which penalty fits?

The rule I kept throughout: the AI summarizes, cites facts and advises. A human clicks Take Action or dismisses the report.

How it works

Right-click a message -> Apps -> Report Message
        |
        v
Report modal (message ID, author, channel and server are bound at intake)
        |
        v
Verity bot (Discord.js v14)
        |  POST /rooms -> one private Switch room per report
        |  + a paired private investigation thread in Discord
        v
+------------------------+
| 1. report-triage       |
| 2. report-investigator |   each one edits the same progress
| 3. moderation-advisor  |   message in the thread as it finishes
+------------------------+
        |
        v
Moderator: ask the agents a follow-up, or open the Take Action modal

A member right-clicks a message and picks Apps -> Report Message. Verity binds the message ID, the author, the channel and the server to one intake session, then opens the report modal. After the report is submitted, the bot creates a new Switch room for it, plus a private thread for the moderators, and the three agents work through the case in order.

How Switch fits in

Switch is open-source infrastructure that puts AI agents into a shared room, the way a person joins a channel. I use it to give every report its own room and to let three agents read each other's work.

One room per report

Every report gets its own room, created through the Switch API (POST /rooms) with a name like report-v-001:

const room = await switchClient.createRoom(
  `Investigation-${reportId}`,
  `Investigation room for Discord incident ${reportId}`
);

Each case lives in its own room, so evidence from one report never shows up in another case's context. The room also holds the outcome once a moderator acts, so there is one place to look when you want to know why a decision was made.

Three agents instead of one

I run three OpenCode agents through the Switch Gateway:

Agent	What it does
`report-triage`	Identifies the rule violation, sets the urgency and flags missing information.
`report-investigator`	Checks the incident itself. It decodes Discord snowflake IDs to get exact timestamps, reads the messages sent just before the incident, and checks the proof files.
`moderation-advisor`	Compares the findings with the server rules, looks up the member's past violations in SQLite, and recommends dismiss, warn, timeout, kick or ban.

The advisor is the only agent that sees the member's history, so the investigator can stay focused on the evidence for this one incident.

Updating Discord in place

Verity posts one progress container in the thread (for example "report-triage is working...") and edits that same message into the finished report as each agent completes. The thread doesn't fill up with separate bot messages. When a moderator takes action, the final container turns green.

Asking the agents questions

If a moderator has a doubt, they type in the thread, for example "@investigator did anyone provoke them first?". Verity forwards the question into the Switch room, the agent answers there, and the answer is posted back into the thread.

Taking action

Take Action opens a modal where the moderator picks the action, adjusts the duration and edits the reason. Then Verity sends the member a DM, applies the action through the Discord API, turns the case container green, writes to the audit channel and posts the outcome back into the Switch room.

Setting up Switch on Windows

The setup took me longer than the code. If you are on Windows, these are the problems I hit and what fixed them.

Problem	What fixed it
Docker couldn't pull Switch's images: `no such host` for `ghcr.io`	It was a DNS failure. Fixing DNS and running `docker pull` again worked, and layers that had already downloaded were kept.
Docker Desktop crashed with a WSL error about a busy disk	Quit Docker, run `wsl --shutdown`, open Docker again and wait for "Engine running". Nothing was lost.
Every OpenCode request failed	OpenCode had picked an image model as its default. Setting a Gemini Flash text model in `opencode.jsonc` fixed it.
`Quota exceeded`	The free Gemini key allowed 20 requests a day on the model I used, and my usage page showed 22 of 20. Agent tools use many requests per question, so a free key runs out fast.
Antigravity wouldn't connect	Switch Console 0.40.1 marks Antigravity as unsupported on Windows, so I used OpenCode.
Humans couldn't read a room	A room created with no chat app attached is "agent-only", and people can't see it. Create rooms with a bridge.

The OpenCode setting, in ~/.config/opencode/opencode.jsonc:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "google/gemini-2.5-flash"
}

Problems I hit while building

Agents calling Switch tools that fail

At first my OpenCode agents tried to call Switch's built-in tools, such as switch_connect_to_room and switch_post_message. Those calls failed with 400 Bad Request because the gateway ran them without any room context.

I stopped fighting it. The agent prompts now start with an override:

SWITCH SYSTEM OVERRIDE:
- Do NOT call switch_read_context, switch_connect_to_room, or switch_post_message. They fail with 400.
- Simply output your complete assessment directly as text in your response.

The orchestrator reads each agent's finished answer from the room's activity stream (/chats/{roomId}/activity). That shows up in Discord about 15 to 20 seconds after an agent finishes.

Sometimes an agent's answer arrives as an attachment instead of message text. For that case I added a fallback that fetches and decodes the file from /chats/{roomId}/media.

Discord modal limits

Discord modals restrict which component types you can use, and the limits depend on the API version. My /settings and Take Action modals kept breaking when a field wasn't where the handler expected it.

I wrote a field extractor that tries interaction.fields.getField() first, falls back to the underlying fields collection, and as a last resort reads the raw component payload. The modals have been reliable since.

Proof without storing media

I wanted reports to accept screenshots without turning the bot into a media server. So Verity keeps only the Discord attachment URLs and checks the image files in memory, to make sure they are real images. If a server turns on Require Evidence, the report modal enforces it before the report is accepted.

What I learned

Several small agents beat one big prompt. When I asked one model to triage, read the logs and recommend a penalty in a single pass, it overweighted the last messages and gave vague summaries. Splitting the work into triage, investigation and advice gave clearer, more specific results.
One room per case keeps evidence apart. It also makes a past decision easy to review.
Keep a human in charge. Members accept a moderation decision more readily when a real moderator reviewed it. The AI is good at sifting through noise and finding the facts. The person provides judgment and accountability.

What I'd want from Switch next

Push events (webhooks or WebSockets) when an agent finishes a turn, instead of polling the activity endpoint.
Room templates, so an agent team with its prompts and tools could be created in one API call.
Room context available to the built-in tools automatically, without a manual connect step.

Try it

Verity is open source under the MIT license. The code, setup steps and architecture diagrams are on GitHub:

github.com/acefyy/verity

Thanks to DevTools Academy, WeMakeDevs and the Switch team for running the Flip the Switch hackathon.

DEV Community: ace