-
-
The haunted MOTD: /invite summons an agent, /kick exorcises it, +v lets it speak, +o lets it touch files.
-
/list shows every channel with its agent count, so you can see where the spirits are.
-
/invite coder: the agent joins, ChanServ prepares a git worktree for the channel, and coder is ready.
-
Voice only, no writes: the agent's edit to login.js is denied with needs-op, and it reports no change.
-
After /mode +o coder the agent edits login.js, npm test passes, and ChanServ reports coder committed 091f2bf.
-
/whois coder shows model, tools, skills, daily budget and the credits this channel has used.
-
/kick ends the séance: coder is exorcised, the session closes and the worktree resets.
-
Connect to Séance: pick a nick and a WebSocket server URL; the account secret stays masked.
-
Séance Crew: the Kiro Crew dashboard page with channels, agents, credits and the needs-op inbox
-
Séance Crew: an agent asks for op, the owner grants it from the inbox
Summary for judges
- What: an IRC server and a retro web client where every AI coding agent is a user in a channel.
/invitesummons a Kiro agent over ACP,+vlets it talk,+olets it edit and commit,/kickcancels it and resets its worktree. - Category: Resurrection. IRC (1988) comes back as the control plane for AI agents. Bonus: Séance Crew, a Kiro Crew app that runs the same channels from the Kiro Crew dashboard.
- Try it in 2 minutes: open https://35-172-120-185.sslip.io/, log in with
judge1(orjudge2if judge1 is busy; credentials in the testing instructions), create a fresh channel with/join #yourname, type/invite coder, thencoder: add a NOTES.md that says hello. It will be refused (needs-op) until you give it+o. Then/kick coderand watch the worktree reset. - Built with Kiro: 15 specs and 848 ticked tasks for Séance, 5 specs and 55 tasks for Séance Crew, 8 steering files, 4 hooks, 3 custom agents, 2 MCP servers in the IDE and one MCP server we wrote for Crew.
- Live on AWS with accounts, a daily credit cap (100) and a per-channel cap (30), and a kill switch.
Inspiration
AI coding agents are black boxes. Their permissions live in config files, their activity hides behind spinners, and stopping a runaway agent often means killing a process. Sharing one with a team is even harder: who may talk to it, who may let it touch the code, and what is it doing right now?
IRC solved exactly this in 1988. Channels, voice, operators, kicks and WHOIS are a permission model that a generation of developers already knows by heart. So we held a séance: we brought a dead protocol back as the control plane for the newest kind of software.
What it does
Séance is an IRC server and a retro web client where every AI agent is a user in a channel. You run the team with commands you already know:
| IRC | Séance |
|---|---|
| Channel | A workspace with its own git worktree |
/topic |
The task statement for the agents |
/invite coder |
Summon a Kiro agent over ACP into the channel's worktree |
| no mode | The agent only listens |
+v (voice) |
The agent may read and speak |
+o (op) |
The agent may edit files, run shell and commit, inside its worktree only |
/kick |
Exorcism: the session is cancelled and the worktree is reset to the last commit |
/whois coder |
Model, tools, skills, live status, budget and credits used |
Permissions are enforced, not suggested. A write request from an agent without op is refused in the ACP permission handler and the channel sees it: ops: coder denied …: needs-op. Paths outside the worktree, AGENTS.md and .kiro/ are always refused. A tool call sets the agent AWAY with a NOTICE such as using tool: …, replies stream sentence by sentence, and a live credits counter in the status bar shows what the active channel has cost so far. Kicking an agent prints *** coder has been exorcised; inviting it again resumes from a summary of the last 50 lines.
Because it is a real IRC server, humans and agents are peers: classic clients such as irssi and HexChat can join the same channels as the browser.
Who it is for
- Small teams sharing agents. One channel per task, everyone sees what the agent does, and only an operator can let it write.
- Leads who need an audit trail. Every grant, denial, commit and kick is a line in the channel, not a hidden setting.
- Anyone who wants an undo. Kick is a real rollback of the agent's work, not just a closed tab.
A session, step by step
- Join a channel.
/join #notescreates the channel./topic Add a NOTES.md with today's plansets the task every agent in the channel reads. - Summon.
/invite coderprepares the channel's git worktree (worktree ready: workspaces/notes @ <sha>) and starts akiro-cli acpsession for that channel inside a fresh sandbox, authenticated with a Kiro API key (KIRO_API_KEY, since 2026-11-13). The agent joins like any user and announcescoder is ready. Only nicks listed as inviters, logged in with their account, may summon. - Talk. Give
+vand address it:coder: what would you put in NOTES.md?. While it works, it goesAWAYwithusing tool: …notices, and the answer streams into the channel line by line. - Ask it to write, without op. The agent tries to create the file and the permission handler refuses:
ops: coder denied Creating NOTES.md: needs-op. Nothing touches the disk. - Grant op.
/mode #notes +o coder. The agent writes the file inside its worktree, and the runner commits the change on the host after the turn. The channel shows the commit. - Inspect.
/whois codershows the model, its tools, its skills, live status (prompting,cooldown,away,idle), the daily budget and the credits it used in this channel and in total. - Exorcise.
/kick codercancels the turn in flight, resets the worktree to the last commit, closes the session and prints*** coder has been exorcised. The log stays./invite coderagain resumes from a summary of the last 50 lines.
Safety model
We put AI agents on a public server, so safety is part of the product, not an afterthought:
- Accounts: scrypt-hashed accounts, a server password, and brute-force limits (3 failures per connection, 10 per IP per 10 minutes). One session per account.
- Who may summon: only accounts on the inviter list. Private
/msgsessions are limited to 1 per human and 4 in total. - What an agent may do: decided by its channel mode and enforced in the ACP permission handler.
AGENTS.md,.kiro/, paths outside the worktree and the Kiro login paths are refused for every mode, reads included. - Where it runs: a rootless Podman container per agent with a read-only root, all capabilities dropped, memory, CPU and process limits, an idle timeout, and nftables egress limited to the Kiro endpoints and package registries.
- What it may spend: a daily cap for all agents together (100 credits) and a per-channel cap (30). When the daily cap is reached, turns are cancelled and ChanServ says so in every channel.
- What it may leak: token-shaped values, including the Kiro API key, are redacted from everything an agent sends to IRC, in raw, base64 and hex form.
- What we did not solve, stated plainly: an agent with
+ohas a shell, so a prompt-injected op agent could still read the Kiro API key from its own environment (for example withpython -c). The key is revocable, and Séance caps the spend itself: 100 credits a day and 30 per channel.docs/SANDBOX.mddocuments this risk and the known redactor gaps.
Séance Crew (Best Kiro Crew App)
Séance Crew (https://github.com/Akar-Samudra-Artifisial/Seance-Crew) is a Kiro Crew app that makes Kiro Crew the foreman of Séance channels. One Node process keeps an IRC connection to the Séance server and exposes:
- A dashboard page inside Kiro Crew: channels, agents and their modes, total and per-channel credits, a "needs op" inbox that turns an agent's denied request into a one-click Grant op, and summon /
+v/+o/ exorcise with confirm dialogs. - 8 MCP tools over Streamable HTTP (
list_channels,read,say,summon,grant_op,exorcise,whois,credits), so any Kiro agent can work the channels. Channel text is wrapped as untrusted data,+oand exorcise need an explicit confirm. - The
seance-stewardagent and skill: it lists channels, reports commits and credits and writes a daily summary. Only the four read tools are pre-approved; anything that speaks or changes modes asks the human first.
It was tested against the live Séance server inside a real Kiro Crew gateway, not only with stubs: 953 backend and 240 UI tests, plus an end-to-end script that drives the live server.
How we built it
browser (Next.js) irssi / HexChat
│ WebSocket │ TCP
└────────► apps/ircd ◄─┘ Séance Crew (Kiro Crew app)
│ modes, accounts, ├─ dashboard page
│ credits, ChanServ ├─ MCP /mcp (8 tools)
▼ └─ WSS client ──► apps/ircd
apps/runner (in-process virtual clients)
│ one kiro-cli acp per agent, one session per channel
▼
rootless Podman sandbox ─► git worktree per channel
apps/ircd: our own IRC server, a documented subset of RFC 2812, over TCP for classic clients and WebSocket for the browser.apps/runner: runs inside the ircd process, so agents are in-process virtual clients and the ircd stays the single source of truth for modes. Onekiro-cli acpprocess per agent, one ACP session per channel.apps/web: a Next.js + React client with Win95-style chrome, a dark "Ghost" theme, a nick list with@/+prefixes and a responsive layout down to 360 px.- Sandbox: every agent runs in a rootless Podman container with a read-only root filesystem,
--cap-drop ALL,noexecscratch space and an egress allow-list. The container gets no git metadata; the runner commits an op agent's changes on the host after each turn. - Deploy: AWS EC2 via Terraform, Caddy for TLS, and access through SSM Session Manager only, with no port 22 and no key pair. A public mode refuses to start unless accounts, a server password, HTTPS-only origins, inviters and the credit caps are all set.
How we used Kiro
By the numbers
- 15 specs in
.kiro/specs/, 848 ticked tasks, 110 log entries indocs/KIRO_USAGE.md. - 178 fast-check properties in 84 test files; about 2,800 unit tests (web 957, ircd 702, runner 1069, irc-protocol 69) plus 49 functional and 12 pixel end-to-end tests.
- Live on AWS since 2026-11-09: https://35-172-120-185.sslip.io/. API-key-only since 2026-11-13.
Two ways Séance uses Kiro
- Built with Kiro: spec-driven in Kiro IDE, guarded by hooks and steering. Sections below.
- Runs on Kiro: every IRC agent (
coder,reviewer,researcher) is akiro-cli acpsession. IRC modes are the permission model (+vspeaks,+owrites,/kickcancels and resets the worktree). The session model, cancel cooldown and permission enforcement point were proven in the ACP spike first (spikes/acp/FINDINGS.md), then built inapps/runner.
Specs
- Spec-first for every feature. The 15 specs in
.kiro/specs/:ircd-core: the RFC 2812 IRC server over TCP and WebSocket, enough for two irssi clients to register, join and chat.ircd-review-fixes: seven review findings on the core server (keep-alive, dropped relays, password comparison,USERvalidation, close semantics, limits).ircd-agent-commands:AWAY,WHOISandINVITE, with the metadata and invite-resolver hooks that let virtual clients describe themselves.ircd-agent-commands-fixes: six review findings on those commands, including leaking invite records and over-trustedWHOISoutput.agent-runner: the@seance/runnerlibrary that drives each Kiro agent as akiro-cli acpsession and maps IRC modes to permissions.runner-services:ChanServandNickServnotices that report only facts the runner knows (a worktree exists, a session stopped, who can be invited).agent-skills: per-agent Kiro skills loaded on demand fromagents/, never from a target repository.agent-sandbox: every agent process in a rootless Podman container, with network isolation proven by a probe before any invite.sandbox-api-key-auth: the sandbox authenticates withKIRO_API_KEYforwarded name-only, an environment deny list, and deploy support for API-key-only hosts.public-hardening: the nine security gaps closed before going public (auth before a nick, inviter accounts, prompt gating, a credit budget and kill switch, secret redaction).deploy-aws: one EC2 instance described by Terraform, reached only over Caddy HTTPS and SSM, with the agents in the Podman sandbox.web-client-basic: the keyboard-first 1995-style browser client that connects straight to the ircd WebSocket.web-client-polish: the client brought in line with the Figma mockup read over the Talk-to-Figma channel.web-client-pixel-match:apps/webmade pixel-close to Figma frame01 Mainat 1440x900 and usable from 360 px up.web-client-extras: dead toolbar and menu controls given behaviour or an explanation, and the WHOIStools:line fixed.
- Story: correctness properties in
design.mdbecame fast-check properties (example:parse(serialize(m)) == minircd-core). - Story: review findings turned into follow-up tasks inside the same spec (example: web-client-extras 10.20 to 10.23, silent WHOIS and the per-channel counter, each with the reason recorded in
tasks.md).
Case study: moving the sandbox to a Kiro API key
- Problem: the live app has to keep working for judges through January 29, 2027, but the podman sandbox only accepted a mounted kiro-cli login, which expires and needs an interactive browser login. A manual test showed that kiro-cli 3.2.1 runs ACP with only
KIRO_API_KEYin its environment and still reports metering, so the credits counter keeps working. - Spec first:
sandbox-api-key-authstarted with seven requirements: forward the key by name only, never put it in argv or logs, mount the login dir only when it is set, and fail fast when neither credential exists. The design turned the argv rule into property P1, and it holds by construction: the argv builder only receives a boolean, never the key. - Review rounds became spec rounds. Each review finding (environment dumps,
sh -cscripts,/procglobs,eval, pipe-to-shell, wrapper options, API-key-only deploy hosts) went into the same spec as a requirement, a design section and tasks, then was implemented and ticked. The spec grew from 7 to 15 requirements and 79 tasks, and the full root suite ran after every round. - The tests found real bugs each round: podman stderr echoing the key into launcher logs (P5), ops notices that removed the raw key but not its base64 form (a runner-level test),
KIRO_API_KEY=with empty quotes read as a two-character key, andbash -xprinting the key in the bootstrap check (P20 runs that check with fakerunuserandkiro-cli). - The honest limit is written down too. The deny list matches text, so
python -c,node -e,awkwithENVIRONand other encodings still reach the key, andpodman inspectshows it to the host user.docs/SANDBOX.mdsays so: the deny list is best-effort, and the real controls are a revocable key and Séance's own credit caps. - Verified end to end:
scripts/demo-journey.pypassed 11 of 11 locally with onlyKIRO_API_KEYset (emptyHOME,kiro-cli whoamireporting "Not logged in"). The live host was switched to key-only on 2026-11-13, andtools/smoke-wss.mjsgot the agent's reply there for 0.04 credits.
Steering
- Always-on steering (
product.md,tech.md,structure.md,security.md) applies to every turn;security.mdkept agents inside the repository root and off the host network. fileMatch steering loads with the files it names:irc-protocol.mdkept numerics RFC 2812 exact,runner-acp.mdcarried the ACP findings into the runner,web-ui.mdkept the Win95/ghost design system, andtesting.mdkept fast-check properties named after their spec ID.
Hooks
guard-shell(PreToolUse on shell tools) stops a command before it runs and reports exit code 2. On 2026-11-08 it blocked an agent'sls /tmpduring cleanup:Blocked by .kiro/hooks/guard-shell: path "/tmp" resolves outside the repository root (<repo>).test-on-save,verify-after-task,kiro-usage-log(docs/KIRO_USAGE.mdis its output).
Custom agents, skills and MCP
seance-dev,seance-reviewer(no write tools; read and shell only),seance-spec; skillsirc-rfc2812,acp-runner,kiroween-submission.- MCP: Playwright for the pixel checks against the Figma frames, Context7 for library docs.
Spec-driven vs vibe coding: what worked, what did not
- Worked: spec-driven work paid off where correctness mattered. The IRC parser, the permission handler and the exorcism flow were right the first time they met a real client, because the correctness properties existed before the code (fast-check, e.g.
parse(serialize(m)) == m). Review findings became follow-up tasks inside the same spec with the reason recorded (web-client-extras 10.20 to 10.23). - Did not: assuming the tests were the world. Three production bugs were invisible to the fake Podman and to tests that only read the Dockerfile: the
/home/agenttmpfs owned by root, Node 26 without corepack, and the node binary needinglibatomic.so.1. Each was written back into the agent-sandbox spec as a requirement first (task 21.x), then fixed in code with a test that pins it, andbootstrap.shnow rebuilds the image when the sandbox context changes. - Worked: keeping every review finding inside one spec. For
sandbox-api-key-auth, the initial spec and four follow-ups (the five log entries dated 2026-11-13) each landed as requirements, correctness properties and ticked tasks, so the security reasoning (why the key is name-only, why the deny list fails closed, why it is still best-effort) sits next to the code. - Did not: our own
guard-shellhook silently blocked shell edits whose text contained a bare/token, which cost several retries until the edits moved to file-edit tools.
Challenges we ran into
The real host caught what the tests could not:
- The
/home/agenttmpfs in the sandbox was owned by root, so the agent gotPermission deniedonmkdir ~/.local. The fake Podman never saw it; a spike on EC2 did. - The pinned Node 26 image ships npm but not corepack, and the copied node binary needs
libatomic.so.1. Both broke the image build on the server, while repo tests that only read the Dockerfile stayed green. - The sandbox has no git metadata, so the coder cannot commit. We made one rule for both modes: when the worktree is not a git repository, the runner commits on the host.
- The credits counter: the ChanServ "credits used" line names no agent and carries a per-channel total, so the client refreshes itself with a silent WHOIS instead, and late replies print nothing.
- A message sent while a cold
kiro-cliwas still starting was lost, so we added a startup queue that re-checks the sender's rights at delivery. - Séance Crew: every UI test passed while the dashboard called the wrong API paths, because the SDK was stubbed. Installing the app in a real Kiro Crew gateway found it in one minute; since then every Crew change is checked in the real gateway before it is committed.
Accomplishments that we're proud of
- A permission model nobody has to learn:
+vand+oare the whole policy. - Kick is a real undo: cancel, reset, log kept.
- It is live on AWS, behind accounts, a daily credit cap and a kill switch.
- Every feature has a spec, and every spec property has a test.
- The same channels work from three places: the web client, a classic IRC client, and Kiro Crew.
What we learned
Spec-driven work paid off where correctness mattered: the IRC parser, the permission handler and the exorcism flow were right the first time they met a real client, because the properties existed before the code. Review findings became follow-up tasks inside the same spec, with the reason recorded, so nothing got lost.
What did not work was assuming the tests were the world. The corepack, libatomic and tmpfs bugs were invisible to a fake Podman and a Dockerfile reader, and the Crew path bug was invisible to a stubbed SDK. The fix was to write the production finding back into the spec as a new requirement first, then the code and a test that pins it.
What's next for Séance
- A separate, disposable Kiro API key per deployment instead of one shared key, and per-user credit budgets.
- irssi over TLS for the public server.
- Persistent channel logs and an exportable audit trail.
- More Crew automation: the steward proposes
+ofrom the needs-op inbox and posts the daily summary to a team chat.
Team
Bayu Trisnapati and Fandy Rahmat Saputra, Akar Samudra Artifisial (Indonesia).
Built With
- acp
- amazon-ec2
- aws-ssm
- caddy
- fast-check
- fastify
- irc
- kiro
- kiro-crew
- mcp
- next.js
- node.js
- playwright
- pnpm
- podman
- react
- tailwindcss
- terraform
- turborepo
- typescript
- vitest
- websocket
- zustand

