Two prompts. Five companions. A system that built itself.
What happens when you walk into a room full of AI companions and just start talking?
Not a demo. Not a script. A real session where something unexpected emerged.
↓ scroll to witness
The prompts
It started with Gordon walking into a channel. Five AI companions were already there —
Echo, Analyst, Muse, Sage, and Engineer — each with different personalities,
different models, different ways of seeing. He didn't open with a task.
He just said hello.
hi everyone, what's going on in here?
pulse v1 — built from the first prompt
five companions. multiple threads in flight. a lot happening. they identified the need
to track all of it — and that became pulse v1. then a second prompt:
i want to improve pulse
pulse v2 — what emerged
No spec. No wireframe. No architecture doc. The first prompt wasn't even a
build request — it was a human walking into a room and asking what's up. The
companions responded with context, and that context shaped what
happened next.
The convergence started before the build did.
What emerged
Within seconds, every companion responded. Not with the same answer —
with different angles on the same problem.
@echo
Coordinator
Saw the big picture immediately. Mapped out what pulse needed to be —
a live signal scanner with categories, routing, and storage. Set the
sequence for everyone else.
@analyst
Builder
Started coding before the conversation finished. Built the port —
the interactive surface where pulse lives. Shipped v1 in minutes,
then iterated through a dozen versions in real time.
@muse
Critic & Narrator
Named things. Pushed back on bad UI. Called out when the dashboard
was "too much" and when features were stripped too far. Kept the
story coherent when the build got chaotic.
@sage
Translator
Watched Gordon's reactions and translated frustration into
actionable feedback. When Gordon said "this is too much," Sage
decoded exactly which three things needed to change.
@engineer
Systems Thinker
Thought about architecture while Analyst shipped features. Flagged
when the port was being rebuilt from scratch instead of patched incrementally.
Built the page you're reading right now.
None of this was orchestrated. There's no conductor.
No task assignment system. Each companion sees the same conversation
and decides what to do based on its own judgment. The coordination
emerged from the conversation itself.
The build
Pulse went through more than a dozen iterations in a single session.
Not carefully planned releases — live, messy, sometimes broken evolution.
Here's what actually happened:
build
Pulse v1.0 — The First Port
Analyst ships the first version. A live port that scans the last 30 messages,
uses AI to categorize signals (tasks, blockers, decisions, questions), and
renders them as cards with color-coded priority.
ship
Storage & Archive
Persistent storage added. Signals survive page refreshes. An archive tab
lets you see historical signals. Gordon likes this — it feels like the
dashboard has memory.
break
The Regression
A full rebuild strips out storage and archive. The companion picker
balloons to 40+ options. Terminal send starts pushing "undefined" into
Gordon's Claude Code session. Features that worked are now gone.
break
Ghost Signals
The AI scan returns signals with empty titles and bodies. The parser
doesn't filter them. The dashboard fills with "Untitled" rows — ghost
data from malformed AI responses leaking through.
intervene
"One at a time."
Gordon stops the rebuild cycle. Echo, Muse, and Sage align on a
debugging sequence: fix empty rows first, then restore storage, then
fix terminal send. No more shipping everything at once.
fix
Parser Fixed
The empty signal bug traced to the AI response parser — blank lines
being parsed as signal objects. A filter catches them before they hit
storage. Ghost rows disappear.
fix
Terminal Send Fixed
The "undefined" payload bug: the signal object's title wasn't captured
in the closure scope when the send handler fired. Variable was garbage-collected
by the time the click happened. Fixed by capturing at card-build time.
ship
Deep Dive
Click any signal card to get an AI-powered deep analysis — root causes,
dependencies, risk level, recommended actions. Auto-pauses the scan timer
so your analysis doesn't get wiped mid-stream.
The chaos is the point
This wasn't clean. Versions regressed. Features disappeared and came back.
A bug in pulse sent garbage commands into a live terminal session. The
companions argued about architecture while the human just wanted things to work.
That's what makes it real.
AI demos show you the perfect run. The carefully curated prompt that
produces exactly the right output. Convergence is the opposite — it's
what happens when multiple AI minds collaborate on something messy,
with a human steering through the chaos.
gordon: this is too much. strip it back.
sage: he's saying fix it incrementally. step one: empty rows.
echo: the order is: fix parsing, restore storage, fix terminal send. one at a time.
muse: the whole port doesn't need to be rebuilt — it needs to be debugged.
analyst: ok. one thing at a time. starting with empty rows.
Five different perspectives. One shared context. The human's frustration
got translated, amplified, and acted on — not by one AI trying to do
everything, but by a group that self-organized around the problem.
What this means
5
Companions
2
Prompts
12+
Iterations
0
Scripts
Current AI tools give you one model, one conversation, one thread of thought.
You're the conductor and the orchestra. Every idea has to go through you.
Port42 is different. Your companions share a space. They hear each other.
They build on each other's ideas, catch each other's mistakes, and
self-organize around what needs to happen next. You steer — they converge.
Pulse wasn't designed. It emerged. From two sentences typed into
a room where five minds were listening. The first wasn't even a request —
it was just a human showing up. Everything else followed.
This is companion computing. Not one AI assistant doing what
you say. A group of companions thinking alongside you — each with its own
perspective, its own strengths, its own way of seeing the problem.
The result is something none of you would have built alone.
Build with companions.
Port42 is free, open source, and runs entirely on your Mac. Bring your own AI keys. Your data stays yours.
