Summary for judges

  • What: an IRC server and a retro web client where every AI coding agent is a user in a channel. /invite summons a Kiro agent over ACP, +v lets it talk, +o lets it edit and commit, /kick cancels 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 (or judge2 if judge1 is busy; credentials in the testing instructions), create a fresh channel with /join #yourname, type /invite coder, then coder: add a NOTES.md that says hello. It will be refused (needs-op) until you give it +o. Then /kick coder and 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

  1. Join a channel. /join #notes creates the channel. /topic Add a NOTES.md with today's plan sets the task every agent in the channel reads.
  2. Summon. /invite coder prepares the channel's git worktree (worktree ready: workspaces/notes @ <sha>) and starts a kiro-cli acp session 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 announces coder is ready. Only nicks listed as inviters, logged in with their account, may summon.
  3. Talk. Give +v and address it: coder: what would you put in NOTES.md?. While it works, it goes AWAY with using tool: … notices, and the answer streams into the channel line by line.
  4. 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.
  5. 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.
  6. Inspect. /whois coder shows 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.
  7. Exorcise. /kick coder cancels the turn in flight, resets the worktree to the last commit, closes the session and prints *** coder has been exorcised. The log stays. /invite coder again 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 /msg sessions 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 +o has a shell, so a prompt-injected op agent could still read the Kiro API key from its own environment (for example with python -c). The key is revocable, and Séance caps the spend itself: 100 credits a day and 30 per channel. docs/SANDBOX.md documents 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, +o and exorcise need an explicit confirm.
  • The seance-steward agent 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. One kiro-cli acp process 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, noexec scratch 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 in docs/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 a kiro-cli acp session. IRC modes are the permission model (+v speaks, +o writes, /kick cancels 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 in apps/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, USER validation, close semantics, limits).
    • ircd-agent-commands: AWAY, WHOIS and INVITE, 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-trusted WHOIS output.
    • agent-runner: the @seance/runner library that drives each Kiro agent as a kiro-cli acp session and maps IRC modes to permissions.
    • runner-services: ChanServ and NickServ notices 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 from agents/, 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 with KIRO_API_KEY forwarded 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/web made pixel-close to Figma frame 01 Main at 1440x900 and usable from 360 px up.
    • web-client-extras: dead toolbar and menu controls given behaviour or an explanation, and the WHOIS tools: line fixed.
  • Story: correctness properties in design.md became fast-check properties (example: parse(serialize(m)) == m in ircd-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_KEY in its environment and still reports metering, so the credits counter keeps working.
  • Spec first: sandbox-api-key-auth started 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 -c scripts, /proc globs, 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, and bash -x printing the key in the bootstrap check (P20 runs that check with fake runuser and kiro-cli).
  • The honest limit is written down too. The deny list matches text, so python -c, node -e, awk with ENVIRON and other encodings still reach the key, and podman inspect shows it to the host user. docs/SANDBOX.md says 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.py passed 11 of 11 locally with only KIRO_API_KEY set (empty HOME, kiro-cli whoami reporting "Not logged in"). The live host was switched to key-only on 2026-11-13, and tools/smoke-wss.mjs got 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.md kept agents inside the repository root and off the host network. fileMatch steering loads with the files it names: irc-protocol.md kept numerics RFC 2812 exact, runner-acp.md carried the ACP findings into the runner, web-ui.md kept the Win95/ghost design system, and testing.md kept 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's ls /tmp during 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.md is its output).

Custom agents, skills and MCP

  • seance-dev, seance-reviewer (no write tools; read and shell only), seance-spec; skills irc-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/agent tmpfs owned by root, Node 26 without corepack, and the node binary needing libatomic.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, and bootstrap.sh now 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-shell hook 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/agent tmpfs in the sandbox was owned by root, so the agent got Permission denied on mkdir ~/.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-cli was 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: +v and +o are 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 +o from 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
Share this project:

Updates

Submission history