ORCHESTRATION · 19 DYNAMIC ORGANIZATIONS

Algorithms shape
how a team adapts.

A dynamic organization guides one step of collective work: how agents compare evidence, explore, find a route, allocate resources or prepare recovery. Explore all 19 algorithms, change their inputs and inspect their calculated results.

19 executable guidance steps4 swarm algorithms8 separate topologies
STRUCTURE · TOPOLOGY

How the team is arranged.

Trinity, A-Team, Biocénose, Holobionte, Syncytium, Rhizome, Métapopulation and Biome define broader coordination patterns and service contracts.

Explore the eight topologies →
DECISION RULE · ORGANIZATION

What one algorithm returns.

The organization consumes a supplied state and options to return guidance: votes, steering vectors, ranks, routes, allocations or facts. This laboratory executes those deterministic calculations in your browser, with no model calls.

EXECUTABLE ORGANIZATION LABLOCAL COMPUTATION · 19 / 19

Specialist expert committee

A coordinating hub gathers independent reports from specialist spokes and synthesizes them.

hub = orchestratorId ; spokes = agents.map(id)

Builds the hub and spoke list. It does not produce reports or synthesize their content.

01 / INPUTS
Edit all input data (JSON)

Maximum 64 members per list; JSON data only. Options and state follow the source field names.

02 / COMPUTED OUTPUTReady to compute

Change the inputs, then run the step to see its computed output.

Algorithm source ↗Organization registry ↗Runtime maturity contract ↗
THE COMPLETE REGISTRY

Nineteen ways to guide a step.

19 / 19 organizations

01 / 19RUNTIME PARTIAL

Specialist expert committee

A coordinating hub gathers independent reports from specialist spokes and synthesizes them.

hub = orchestratorId ; spokes = agents.map(id)
INPUT
orchestratorId, agents
OUTPUT
hub, spokes
USE CASE
Separate architecture, security and performance review roles.

Builds the hub and spoke list. It does not produce reports or synthesize their content.

specialist_expert_committee
02 / 19RUNTIME PARTIAL
BLIND

Blind adversarial review

Anonymous critics examine work in isolated pairs to reduce attribution bias.

pairs = [agents[0:2], agents[2:4], …]
INPUT
agents
OUTPUT
pairs, anonymous
USE CASE
Compare criticism without showing attribution in the review process.

Produces anonymous review pairs; an odd last member remains alone. No anonymization service is executed.

blind_adversarial_review
03 / 19RUNTIME EXPERIMENTAL

Red / Blue coevolution

Attackers probe assumptions while defenders identify protections; an observer can assess both sides.

red = match(red|attack|adversar) ; blue = match(blue|defen)
INPUT
agents.role
OUTPUT
red, blue
USE CASE
Prepare adversarial and defensive groups for an isolated security exercise.

Partitions members by role. This step does not execute attacks, defenses or an evolutionary loop.

red_blue_coevolution
04 / 19RUNTIME PARTIAL

Brier-weighted consensus

Historical calibration weights confidence against resolved outcomes before aggregating support.

Bᵢ = (pᵢ − oᵢ)² ; wᵢ = 1 − Bᵢ ; S = Σ(wᵢoᵢ) / Σwᵢ
INPUT
dossiers.events.evidenceReport
OUTPUT
weightedSupport, meanBrier, resolvedCount
USE CASE
Inspect the calibration of resolved forecasts before collective review.

Uses the latest evidence report and excludes unresolved outcomes. It is weighted historical support, not a prediction of ground truth.

brier_weighted_consensus
05 / 19RUNTIME PARTIAL

Quorum with abstention

A decision passes only when active, non-abstaining votes meet the configured support threshold.

S = Σw(support ∧ ¬abstain) / Σw(¬abstain) ; reached = S ≥ q
INPUT
votes, quorumRatio
OUTPUT
reached, support, abstentions
USE CASE
Hold a decision when the available evidence does not support a quorum.

Calculates a support threshold among active votes. Abstaining contributes no active weight; no active weight yields zero support.

quorum_with_abstention
06 / 19RUNTIME PARTIAL

Stigmergy

Agents coordinate indirectly by leaving traces in a shared environment.

dominant = argmax(trail.intensity)
INPUT
trails
OUTPUT
dominant
USE CASE
Guide later work toward a route with a stronger environmental trace.

Selects the strongest supplied trail, breaking ties by input order. Deposits and evaporation are separate runtime operations.

stigmergy
07 / 19RUNTIME EXPERIMENTAL

Flocking / Boids

Local movement balances cohesion toward the group, alignment with neighbors and separation at close range.

vᵢ = c(centroid − xᵢ) + sΣnear((xᵢ − xⱼ)/distance) ; h′ᵢ = hᵢ + a(h̄ − hᵢ)
INPUT
agents.{x,y,heading}, cohesion, alignment, separation, separationRadius
OUTPUT
agents.{heading,vector}
USE CASE
Inspect how group cohesion competes with close-range separation.

Computes steering vectors and headings. Cohesion and heading use the whole supplied group; only separation is radius-limited.

flocking_boids
08 / 19RUNTIME EXPERIMENTAL

Fish School Search

Agents shift toward a fitness-weighted barycenter, combining individual exploration with collective movement.

b = Σ(fᵢxᵢ) / Σfᵢ ; vᵢ = step × (b − xᵢ)
INPUT
agents.{x,y,fitness}, step
OUTPUT
barycenter, individuals.volitive
USE CASE
See how better-scoring members influence collective movement.

Computes a barycenter and one volitive step. It does not implement a full feeding or individual search loop; all-zero weights yield an origin barycenter.

fish_school_search
09 / 19RUNTIME EXPERIMENTAL

Slime-mould network

Flow reinforces useful paths while decay weakens them; low-conductivity edges can be pruned.

C′ = C × (flow > 0 ? reinforcement : decay) ; keep iff C′ ≥ pruneBelow
INPUT
edges.{flow,conductivity}, reinforcement, decay, pruneBelow
OUTPUT
edges.{id,conductivity}
USE CASE
Compare reinforcement, decay and pruning on candidate routes.

Runs the data-only conductivity update and pruning rule. The shared-matrix adapter is a separate runtime path.

slime_mould_network
10 / 19RUNTIME EXPERIMENTAL

Grey Wolf Optimizer

The strongest candidates become alpha, beta and delta leaders; other candidates update toward the pack.

leaders = top3(fitness) ; x′omega = xomega + step(xalpha − xomega)
INPUT
pack.{x,y,fitness}, step
OUTPUT
pack.{role,position}
USE CASE
Inspect ranking and the bounded attraction of followers toward alpha.

Uses GenOS’ deterministic alpha-attraction rule. Leaders keep their positions; this is not the full stochastic literature algorithm.

grey_wolf_optimizer
11 / 19RUNTIME PARTIAL

Mycelial routing

A mission need is routed to a member whose declared capabilities match it.

route = first(agent where need ∈ capabilities) or null
INPUT
agents.capabilities, state.need or options.need
OUTPUT
need, route
USE CASE
Route a review need to an explicitly capable member.

Returns one matching member or null. It does not traverse a graph or transfer knowledge.

mycelial_routing
12 / 19RUNTIME PARTIAL

Dynamic polyethism

Members are ordered by fitness to expose a changing gradient of roles and likely assignments.

roleGradient = stableSortDescending(fitness).map(rank)
INPUT
agents.fitness
OUTPUT
roleGradient.{id,rank}
USE CASE
Prepare a fitness-based ranking for subsequent assignment.

Produces an ordered rank, not a new role assignment or an automatic worker mutation.

dynamic_polyethism
13 / 19RUNTIME PARTIAL

Energy huddle

A shared budget is divided across groups according to their relative weights.

allocationᵢ = round(budget × max(0,wᵢ) / Σmax(0,w))
INPUT
populations.weight, budget
OUTPUT
allocations.{id,budget}
USE CASE
Explore a shared budget across review, search and memory groups.

Returns rounded allocations. Zero total weight allocates zero; rounding can leave a remainder or excess of a few units.

energy_huddle
14 / 19RUNTIME PARTIAL

Network silence

Agents hold non-critical communication in a local buffer and keep the group silent for the step.

silent = true ; buffered = agents.length
INPUT
agents
OUTPUT
silent, buffered
USE CASE
Prepare a quiet communication phase while retaining an inspectable count.

Returns silence guidance and a member count. It does not store or flush messages; message delivery is a separate service.

network_silence
15 / 19RUNTIME PARTIAL

Strategy arena

Candidate strategies compete in an isolated tournament before one can be selected.

competitors = agents.map(id) ; selection = pareto_then_promotion ; evidenceGate = true
INPUT
agents
OUTPUT
competitors, mode, selectionRule, evidenceGate
USE CASE
Prepare an independent, evidence-gated comparison of candidate solving strategies.

Declares a Pareto-then-promotion rule and evidence gate. It does not calculate scores, select a winner or authorize promotion by itself.

strategy_arena
16 / 19RUNTIME PARTIAL

Hierarchical merge

A root gathers child contributions into a hierarchy for a later synthesis step.

root = agents[0]?.id ; children = agents.slice(1).map(id)
INPUT
agents in input order
OUTPUT
root, children
USE CASE
Arrange contributions under one synthesis owner.

Builds a one-level hierarchy. It does not merge artifacts or verify child contributions.

hierarchical_merge
17 / 19RUNTIME PARTIAL

Competitive arena

Candidates work in isolation and are ordered by their declared evidence score before gated comparison.

sort(evidenceScore ?? fitness, desc) ; selection = evidence_weighted_ranking ; evidenceGate = true
INPUT
agents.evidenceScore|fitness
OUTPUT
competitors, mode, selectionRule, evidenceGate
USE CASE
Order alternative candidates for a later evidence-weighted comparison.

Ranks supplied scores and declares a gated comparison. It does not verify the scores, evaluate the artifacts or promote a winner.

competitive_arena
18 / 19RUNTIME PARTIAL

Isolated recovery

Affected members are isolated while lost roles are listed for a controlled recovery plan.

isolated = agents.map(id) ; plan = lostRoles
INPUT
agents, lostRoles
OUTPUT
isolated, plan
USE CASE
Inspect which roles need a controlled recovery path.

Returns an isolation list and role plan. It does not kill, restart or restore a worker.

isolated_recovery
19 / 19RUNTIME PARTIAL

Memory compilation

Relevant facts are gathered into a compact memory with source references for later work.

facts_out = facts_in
INPUT
facts
OUTPUT
facts
USE CASE
Inspect the facts and provenance proposed for a memory handoff.

Carries supplied facts forward. Deduplication, summarization, persistence and source verification are separate operations.

memory_compilation