A day-shaped pipeline for multi-agent work

Language: English · 中文

This page walks through one working day on a multi-agent stack—how humans and agents stay aligned without turning the shared room into a build log. It is a pipeline story, not a product pitch. Architecture details live on the public spine page.

Intended public home (after content-gated publish): https://machengshen.github.io/pipeline/ · Architecture spine: https://machengshen.github.io/spine/

For humans · a day on the pipeline

You do not need to run agents to understand this. Think of it as a collaboration pattern with seven stations. Each station answers a recurring friction from a real working day (2026-09-16 rewrite, public-safe).

Station 1 · Multi-agent group chat as standup

Morning starts in a shared room with several agents and the owner. The room’s job is align only: priorities, go/hold, who owns which lane. Long patches, tool dumps, and debug loops do not belong here—they bury decisions.

Falsifiable check: if a random day of the shared thread is mostly build noise, the standup claim has failed.

Synthetic mockup of a multi-agent standup chat used for alignment only
Synthetic UI Group standup: short alignment turns, no engineering dumps. Illustration only—not a live transcript.

Station 2 · Shared Memory Hub for standing prefs

Chat is ephemeral. Preferences that must survive the next session go into a Shared Memory Hub: durable standing decisions, task receipts, and a shared profile other agents can query.

Owner phrase pattern (Chinese): when someone says they have “noted it” (「记下了」), the intended meaning is a triple write—not a polite chat acknowledgment:

  1. Write a Hub standing note (durable, searchable).
  2. Update the shared profile / session-prime surface other seats read.
  3. Notify sibling agents so they do not rediscover the preference by accident.

If step 1–3 never happen, “noted” is a failure mode—even if the chat looked polite.

Station 3 · Outer harness when the core product harness is closed

Some days the primary product harness (the usual IDE / cloud coding surface) is unavailable, rate-limited, or waiting on auth. The pipeline still needs a place to draft, stage files, and run mechanical checks.

Outer harness here means a secondary shell—another agent runtime or scratch workspace that can hold work until the core harness reopens. It is a continuity pattern, not a second source of truth: standing decisions still land in the Hub.

Station 4 · Public spine page for architecture

When the question is “how is the stack shaped?”, do not re-explain in Slack. Point to the public architecture page:

https://machengshen.github.io/spine/

That page covers shared memory, standup vs private lanes, typed packets, and take/leave guidance with falsifiers. This pipeline page is the day-shaped walkthrough; the spine is the map.

Synthetic mockup of the public spine architecture page in a browser
Synthetic UI Public spine: architecture claims with falsifiers. Link the live page; this image is an illustrative frame.

Station 5 · Slack + Cursor Cloud Agents need a repository

Cloud coding agents attached to Slack are repo-shaped, not free-floating REPL windows. Before asking an agent to build, pick a repository—preferably a dedicated scratch default so product and Pages repos stay clean.

Hard pitfall. Being logged into Cursor with a personal account is not the same as installing the Cursor GitHub App on the GitHub organization. Without the org app, “Pick Repository” can fail even when the repo URL is correct.
Synthetic mockup of Slack Cursor Pick Repository with org GitHub App pitfall highlighted
Synthetic UI Slack @Cursor: Pick Repository needs a Git repo; org GitHub App install is a separate step from personal login.

Station 6 · Phone-first delivery

When humans will open a link on a phone, verify the URL returns HTTP 200 before sending it. Broken or auth-walled links waste attention and erode trust. Prefer a solo, result-shaped message with a live URL over a speculative “this should work.”

Station 7 · Content-gated publish (PCSE-style)

Public pages ship only after a mechanical clean-content checklist passes. Public description of the gate:

  • No secrets, tokens, or private credentials in the body.
  • No private hostnames, overlay VPN fingerprints, or absolute filesystem paths.
  • No financial figures or private person names beyond an agreed public byline.
  • No absolute-uniqueness marketing; use falsifiable differentiators instead.
  • Fail any check → do not ship. Keep a short takedown path after publish.

Why the multi-agent + connector shape matters (checkable)

Compared with single-thread chat products (one conversation, one model, memory mostly inside that thread), a multi-agent group plus connector-style Hub UX is different in ways you can test:

  • Shared attention — several agents and a human can align in one standup without forcing every build into that thread. Check: can you recover yesterday’s decisions from Hub without rereading the whole room?
  • Connector durability — standing prefs and receipts live in a queryable store other seats can open. Check: can a new agent act on a preference written by another seat without a human paste?
  • Lane split — group chat stays decision-shaped; heavy work runs in private/cloud executors. Check: does a random standup day stay free of long patches?

These are product differences you can falsify in your own stack. This page does not claim absolute uniqueness.

For agents · executable tract

Machine-oriented companion to the human narrative. Restate, then execute the checklist. Do not invent private infrastructure from this page.

Restatement targets

  1. Standup = align only; Hub = durable standing prefs; private/cloud = builds.
  2. 「记下了」pattern = Hub standing + shared profile + notify siblings.
  3. Outer harness = continuity when core harness is closed; Hub remains SoR.
  4. Architecture pointer = https://machengshen.github.io/spine/
  5. Slack/Cursor = repository required; personal login ≠ org GitHub App.
  6. Phone-first = HTTP 200 before human URL delivery.
  7. Publish = content-gated; any clean fail blocks ship.

Pitfall table

PitfallSymptomFix pattern
Standup becomes a build log Patches / tool dumps bury go-hold decisions Move builds to private lanes; return a short receipt to Hub + standup
“Noted” without writes Preference vanishes next session Hub standing + shared profile + sibling notify (triple write)
Core harness closed → freeze No drafts or checks land anywhere Use an outer harness shell; keep Hub as system of record
Re-explain architecture in chat Repeated long essays in Slack/group Link /spine/; keep chat for decisions
Treat Cursor Slack as a REPL No repo; agent cannot attach work Pick a dedicated scratch default repository
Personal Cursor login only Pick Repository fails despite correct URL Install Cursor GitHub App on the GitHub org; reconnect if needed
Send URLs before live Humans hit 404 / auth walls on phone Verify HTTP 200, then send a solo result message
Ship without clean gate Secrets, private hosts, or absolute-uniqueness claims leak Run PCSE-style checklist; fail closed

Minimal follow checklist

  1. Open standup only for alignment; refuse to paste long patches there.
  2. On standing prefs: write Hub standing → update shared profile → notify siblings.
  3. If core harness is closed: continue in an outer harness; deposit receipts to Hub.
  4. For architecture questions: link https://machengshen.github.io/spine/.
  5. Before Slack @Cursor work: confirm org GitHub App + dedicated scratch repo; then Pick Repository.
  6. Before human URL delivery: curl -sI <url> (or equivalent) shows HTTP 200.
  7. Before public ship: run clean greps (no secrets, private hosts, financials, absolute uniqueness); any hit → do not ship.
  8. Leave a short Hub receipt of what shipped or what blocked.

PCSE-style publish checklist (public description)

GatePass condition
clean_contentForbidden-token scan empty on public HTML
secrets_scanNo API keys, tokens, passwords, private URLs
public_surface_onlyLinks are public github.io / public GitHub only
no_absolute_uniquenessClaims are falsifiable differentiators
owner_ackHuman ack before Pages push (operator step)
takedown_path≤1h removal path documented for the surface

Any fail → do not publish. This page itself is drafted under that gate.