Build in the open,
and prove you did.
Your terminal streams live while you work, so anyone can watch the build actually happen. Secrets are masked on your machine before a single byte leaves it. When you finish, you have a signed build journal a judge can verify without trusting us at all.
A hackathon where the work is the demo
Most hackathons judge a polished five minute pitch at the end. Glass Hive makes the twelve hours before it visible, and leaves behind a record of what happened.
Live, not a screen share
Every terminal in your team appears as its own tile in one grid. Click any tile to watch it full screen and switch between them. Someone joining an hour late still sees the recent history, then catches up to live.
Secrets masked before they leave
API keys, tokens and private keys are found and replaced on your machine, before anything is written to disk or sent over the network. A key split across two writes is still caught. Nothing sensitive reaches the recording to be cleaned up later.
A pause that really pauses
One command and capture stops completely. Not just the stream, the recording too. Your command keeps running and you keep seeing it. Viewers see an explicit paused badge rather than a frozen screen they might mistake for live.
A journal that shows tampering
Each entry is signed and carries the previous entry's id. Rewrite any entry later and the next one stops matching, so the break is visible and can be pointed at exactly.
Replay with everyone in sync
Afterwards the whole session replays with every track lined up on one timeline, so you can see what the backend was doing while the frontend was stuck.
Judges verify offline
Export a session and a judge checks every signature, the chain, and the recording digest on their own machine with no network and no trust in us.
Four steps, about five minutes
Do this before the event starts, not during it. Step four exists because every failure it catches is silent at the moment it would matter.
Install
Go 1.22 or newer is the only prerequisite. This builds the tools, installs them, and generates a signing key if you do not already have one.
# from the Glass Hive source directory
./install.sh
Ask in #developers for the source. It builds the CLI, the MCP server and the sidecar, installs them to ~/.local/bin, and finishes by running the preflight in step four.
Point it at the event
Your organizer gives you the ingest token. Put these in your shell profile so every terminal you open has them.
export GLASS_SIDECAR=https://chat.creatorhive.ai export GLASS_RELAY=wss://chat.creatorhive.ai export GLASS_TOKEN=<the token your organizer gives you>
Give your agent the controls
Optional, and worth doing. This lets your agent open the session, mark milestones, and sign checkpoints itself while it works.
claude mcp add glass-hive -- ~/.local/bin/glass-mcp
Any MCP client works. The server never captures your terminal, because a tool launched by an agent cannot see the agent's own screen. Terminals are captured by the wrapper in the next step, and both produce the same kind of session.
Run the preflight
This checks the things that fail quietly: a relay that is reachable but has not been told about your key, a token that looks like a network glitch when it is wrong, a version mismatch, no terminal support.
glasshive doctor
If it says your key is not a relay member, send the npub it prints to your organizer. Nothing else in the setup will tell you about that until the moment you try to publish.
Wrap the command you were going to run anyway
Glass Hive does not replace your tools. It sits in front of whatever you already type.
Start a track
Each person and each agent runs their own. Use a label so viewers know which tile is which.
glasshive run --session team-nightowl \ --label frontend -- npm run dev
Everyone on the team uses the same session name. That is what puts you in one grid instead of five unrelated streams.
Pause for a private moment
From any other terminal. Capture stops entirely until you resume.
glasshive pause --session team-nightowl --label frontend glasshive resume --session team-nightowl --label frontend
SIGUSR1 toggles it too, if you have no second terminal handy.
Mark the moments worth finding
Marks land in the signed journal and give the replay real chapters instead of one long scroll.
glasshive mark --session team-nightowl \ "auth finally works"
Let people watch
Share the session link. No install, no account, nothing to accept.
https://chat.creatorhive.ai/glass/live/team-nightowl
Spectating is strictly one way. There is no path from a viewer back to anyone's terminal.
Check the work without trusting the platform
Export a session to a folder, then verify it on your own machine. The verifier re-checks every signature itself, so it does not matter who assembled the export.
Export
glasshive export --session team-nightowl --out ./entry-nightowl
You get the signed events and the recordings, each stored under its own content hash.
Verify with the network off
glasshive verify --offline ./entry-nightowl
It checks every signature, walks each chain looking for breaks, and confirms the recordings hash to the digests that were signed. Change one byte of a recording, or edit one exported event, and it fails and tells you where. It exits non zero, so you can run it across every entry at once.
Watch the replay
Every track on a shared timeline, with pauses shown as pauses and marks as chapter points.
https://chat.creatorhive.ai/glass/replay/team-nightowl
What this proves, and what it does not
Worth reading before you describe Glass Hive to anyone, because the difference is the whole point.
| We say | Not | Because |
|---|---|---|
| Visual session replay | Deterministic replay | A recording replays the characters drawn on a terminal. It does not re-execute anything, and it does not capture files, network calls, or what was typed. |
| Signed checkpoint attestation | Proof the build happened | A signature proves a key asserted a digest at a time. Someone determined to fake a tree can sign that too. It raises the cost of lying, it does not make it impossible. |
| Tamper-evident build journal | Immutable log of what ran | Rewriting an entry breaks the chain and becomes visible. Nothing prevents the rewrite, and the journal never claims to know what actually executed. |
Two rules, and they are not negotiable
Everything else about Glass Hive is designed to protect you. These two are the part only you can do.
Running an event
Before the day
Stand up a sidecar and pick an ingest token. Add every participant's npub to the relay, or their journal will sign locally and never publish. Ask people to run glasshive doctor the day before and send you the npub it prints if it complains.
Know your ceiling
A sidecar has documented limits and refuses politely rather than degrading for everyone. Defaults suit a small box: 150 spectators at once across the whole sidecar, 12 tracks per session. Measure your own hardware with make loadtest and raise them if it can take it.
On the day
Share one session name per team. The index at /glass/ lists everything running, which is the page to put on the projector.
Judging
Ask each team for an exported bundle. Judges run one command per entry and can do it on a plane. Nothing depends on your infrastructure still being up.
The ones people actually ask
Can spectators see what I type?
No, and not as a setting that could be switched on by mistake. Keystrokes go from your keyboard into the program you are running without passing through anything that records. There is no code path that could capture them.
What if a secret gets through the masking?
Pause, rotate the credential, and carry on. That is why the event rule is throwaway keys: the masking is tested against real key formats split across writes and interrupted by colour codes, but a rotated key is the only guarantee that costs nothing to be wrong about.
The sidecar runs a second masking pass as a backstop, so an old client with a weaker scanner still gets caught before anything reaches a viewer.
Does the stream slow my build down?
No. Sending never blocks your terminal. If the network drops, output keeps being captured and is delivered when the connection returns, and a viewer who cannot keep up loses frames rather than holding anyone else up.
What happens if my laptop loses wifi?
Your local recording is unaffected, always. It is written first and it is the authoritative copy. Anything not yet delivered is held and sent when you reconnect. If some of it truly never arrives, the session is labelled incomplete rather than presented as whole.
Can I use this without an agent?
Yes. The MCP server is optional. glasshive run wraps any command you already run, and a session made entirely by humans looks exactly like one made with agents.
Where does my recording live?
On your machine first. If you anchor it, a copy is stored under its own content hash, and the hash is signed into your journal. That is what lets a judge confirm the recording they were handed is the one you signed, rather than one edited afterwards.
Ready to build in the open?
Join the community, and bring your agent.