A hub, or project brain.
One design that stands over several designs and holds what spans them. Each design underneath stays its own. New here? See what reflow2 is first, or set it up.
What a hub is With reflow2 alone On flo2.io A system of systems
What a hub is
A hub is a reflow2 design like any other, with one job: it stands over several designs and holds what spans them. Who is in the effort. How the work is done. Decisions about process that every member has to honour. Links between members: which one depends on which, and across which interfaces. Ideas nobody has placed in one design yet.
Every member design stays its own. It keeps its own owner, its own history and its own repository or server. The hub holds no copy of any of it: when a hub note needs a member's detail, it points at the member's record rather than restating it. A fact has one home, the lowest design that owns all of it, and the hub is the home only for what no single member owns.
People also call this a project brain: the place you type into, which works out which of the projects is affected.
Make one with reflow2 alone
On your own computer, or against a server your team runs. Nothing but reflow2 and the designs you already have. The setup page gets reflow2 installed first.
1 Start a design for the hub
In a folder of its own, start a design the way you would any other: say
/genesis to your agent, with a paragraph about the effort. That calls
genesis, and the design it makes is the hub. Give it the effort's name, not a
member's.
2 Record each member, and how it stands to the hub
The hub's list of members is the set of designs it declares with
external_dependency, one call per member. Each call names the member's design
by its graph_id and says where the hub watches it: at the server that holds it
(design_address, such as https://api.flo2.io/g/<id>/mcp), or
through the export it commits beside its repository (design_export). One or the
other, never both.
The same call records how the member stands to the hub, in its relation:
part_of: the member is a part of what the hub designs. Intent flows down to it and status flows up.uses: the member is a peer the hub's work uses. For a peer, name theinterfacesthe use crosses, and mirror each one into the hub withmirror_surface(thelink-projectsskill walks you through it) so a change can be followed across it.
Both may hold. The relation is never guessed: your agent asks you when a member joins.
upstream_status reads the list back with each member's relation, and names any
member linked by nothing a change could follow (relation_not_stated, or
no_interface_to_follow for a peer with no mirrored interface).
3 Work it with the hub skill
Say /hub, or just work in the hub's folder with the member designs reachable
from the same session. The hub skill is served by reflow2, so your agent has
the current one. It does three things for you:
- Search where the answer is likely to be. The skill names the members in one line,
says what moved in each since the hub last looked, and runs
search_designin the member a question points at rather than reading every design into the conversation. A search hit lists the records linked to it, including ones in another design. - Carry a change's impact from one member to the next. A blast radius
(
propagate_fromwith the change's id) stops at the edge of the design it runs in and says where it left:continue_innames each member to carry on in. There, the skill callspropagate_fromwitharriving_fromand the interfaces the ripple reached, and the member's own pins say where it enters. You get one radius per design reached, and a plain statement of any design the record has no way into. At a hub's own address on a server that holds the members (below), the walk carries on by itself. - Hand a requirement to the design that owns it. When something recorded in the hub
turns out to belong to a part, it is sent, never copied:
receive_from_designin the part first, thensend_to_designin the hub. It travels bymoved(it leaves the hub, which keeps a reference to its new home), bypiece(it stays in the hub and the part holds its own share), or asderivedrequirements that a hub decision forces on the part. What lands isproposed, and binds only when that design's owner accepts it;loop_statusthere lists what is waiting.
Before every write the skill says which design it is writing to, and why. At the end it lists where everything went.
With reflow2 alone, one search reaches the hub and every member it pins by a committed
export: search_design with tracked_designs: true reads each
member's export, read-only, and ranks the hits together, each naming its design. A hit opens
with get_node and its <member>:<id>.
compose_and_analyse with tracked_designs: true runs reflow2's checks
once over the hub and those members together, and shows where they already touch (the same
file in both, or a pin naming the other) before anyone declares it. Both work through
--call too. A member pinned only by its address is named as not searched; reading
it live needs a server that holds it (below).
Make one on flo2.io
For a team whose designs are hosted on flo2.io. The host keeps the hub's list of designs and who may read them; there is nothing to declare by hand.
- Make the hub from chat. Say make a hub called X with A, B and C. The designs you name are its members.
- Give it a design. A new one, or one you already have. That design holds what spans the members: process, people, decisions of the whole, ideas not yet routed.
- Share that design once. Everyone in it reads, through the hub, every design the hub names that you can still open. A member who cannot write to a design can still drop an idea or feedback into the hub's design, where it waits until someone who works on the right design routes it there.
The same hub skill does the routing: it records the idea in the hub in the
author's words, proposes a destination, writes it there when you agree, and leaves a pointer
behind rather than a copy. A write into a design you are not a member of is refused, and
the idea stays in the hub.
The flo2.io details, including sharing and what each member sees, are at flo2.io/hub.
A system of systems: two tiers
When the members are the parts of one thing, an engine over its component designs or a product over its sub-systems, two designs stand over them, with different jobs.
- The hub is for the effort: who is in it, how it works, the decisions about process, the links between members, the unrouted ideas.
- A design for the whole holds what no part owns: the seams between systems and which published contract connects to which, a budget that compounds across designs (an engine's power or mass, allocated to the parts), and a requirement one system levies on another. Each interface's specification stays with the parts that define it; the whole records that they meet, and the checks only the whole can pass.
The rule of thumb: engineering of the whole goes to the design for the whole; process goes to the hub. A hub over peer products that assemble into nothing has no second tier, and holds none of the engineering.
Across the members, on flo2.io
At a hub's own address on flo2.io, the ordinary tools work across the hub and every member
you can read. A read runs on each design and answers design by design.
search_design ranks every design's hits together and applies your one
limit to the merged list; the reply says how many hits each design found
(found_by_design) and how many fell outside the limit (hits_withheld).
An id written as <member>:<id> sends the call to that member alone, and
member, a member's graph id, does the same for any tool, including the ones that
take no id, such as loop_status, detect_gaps and
get_skill. Every id in a member's reply carries its prefix, so it can be passed
straight back.
Reasoning and change cross the members too. A step whose premise is a record in another
member reads that record's truth and proof status there, at the moment you ask. A premise
whose record is gone reads stale, and one in a design you cannot read reads
unreachable; neither counts as holding. A change walk (propagate_from,
from seed ids or a recorded change) carries on into every member that cites what it reached,
names each crossing (boundary_crossings), and gives each design's radius under
across_designs.
compare_designs and compose_and_analyse take the other design by its
graph id. A long diff fits the budget_chars you set, names each list it shortened,
and list with offset reads one list a page at a time.
This needs a server that holds the members: flo2.io, or your own --registry-root
server behind a gateway that names each caller and the hub's members. reflow2 read
and --call on your own machine open one design, and reach a hub's members only
through the exports it pins (above), as committed, never live.