Lean Software Production · Volume 1 · August 2026

The Software Factory Radar

Forty-three blips on how teams are getting agents to build software - and on the question underneath all of it: who decides what happens next? One family hands that to an orchestrator walking a graph. The other hands it to a person signing off between phases. Rings are adoption advice, not quality scores.

The question this radar is really about

Both families decompose the work the same way - plan, implement, validate, iterate - and both discovered they needed the same things: a validator kept separate from the doer, checkpoints, an escape hatch to a human. They disagree on one thing. In an autonomous factory the orchestrator resolves each transition by evaluating an edge condition; in a supervised methodology a person resolves it by signing off. Almost everything else follows from that choice.

The adoption numbers are lopsided enough to state plainly and then leave alone: the supervised projects here carry roughly 450,000 GitHub stars between them, the autonomous ones about 3,500. That measures attention, not fitness. Attractor is younger, aimed at a narrower audience, and asks for more trust up front. Whether the gap measures anything else is the argument worth having, and this radar does not settle it.

This radar uses the ThoughtWorks convention: four quadrants that partition every blip, four rings that say what to do about each one. It follows the Lean Software Production lexicon rather than each project's own README vocabulary - a factory is the deployable thing, an assembly line is the graph inside it, a machine is one agent in a non-interactive harness, the orchestrator walks the line and decides what runs next, and a skill is a process encoded in markdown for an agent to follow. Those last two are the axis the quadrants turn on.

The radar

10 August 2026
Adopt Trial Assess Hold Notations & specs Autonomous factories Supervised methodologies Techniques 6 blips · 1 in Adopt 18 blips · 0 in Adopt 8 blips · 1 in Adopt 11 blips · 4 in Adopt 11 → 7  archived, became Fabro 10 → 3  author moved to Dippin 1 2 3 4 5 6 7 8 9 16 17 18 19 20 21 22 23 10 11 12 13 14 15 24 25 26 27 28 29 30 31 32 43 33 34 35 36 37 38 39 40 41 42
6Adopt

We should be doing this now. Proven repeatedly by independent implementers, and cheap enough to start this week.

9Trial

Worth a real pilot on a project that can absorb the risk. Evidence is good; longevity is not yet proven.

17Assess

Understand how it affects you. Read it, run the demo, watch the commit log - but do not build on it yet.

11Hold

Do not start new work on this. Says nothing about whether it is worth studying - check for the dashed halo.

Notations & specs

6 blips · how you author an assembly line

The decisions that matter most here are notational. The format you write the graph in determines whether an assembly line is a diffable artifact in your repo or configuration trapped inside a tool - and, as of this edition, it is the one area where the field's own consensus is being actively attacked.

1

Graphviz DOT

Adopt

The single strongest signal in the survey: 16 of 17 deeply profiled ports, and near enough all 31, independently chose literal DOT to define the assembly line. Nobody was told to. They read the spec and reached for the same format, in thirteen languages, with no coordination. That makes an assembly line a small, diffable, renderable text file that lives next to the code it produces, and it means a line written for one engine is mostly readable by another.

It is in Adopt on evidence, not affection - and read blip 3 before you get comfortable.

2

NLSpec as the durable artifact

Trial

strongDM shipped Attractor as a natural-language specification rather than a reference implementation, and every project on this radar exists because of that choice. The interesting move is treating the spec, not the code, as the thing you version: several ports carry their own copies of the Attractor, agent-loop and unified-client specs in-repo rather than linking out, and attractor-tcl's README frames the repository as specs for agents to build the thing themselves.

Trial rather than Adopt because the failure mode is real and visible here: a natural-language spec is a semantic interface, so two competent implementers reading the same paragraph produced deterministic and model-judged routing respectively, both convinced they were conformant.

3

Dippin

AssessNew
Go21 stars2389 Researchpushed 2026-08-10

A language built specifically to replace DOT as the authoring format while keeping it as the rendering target. Its critique lands on almost everything this radar praises: multi-line prompts become indented blocks instead of \n-escaped strings, model config becomes a typed field instead of an untyped attribute, branching becomes when ctx.x != "y" instead of a quoted expression, unknown attributes become diagnostics (DIP001-DIP160) instead of silent typos, and machine types become explicit agent / tool / human keywords instead of overloaded node shapes.

What makes it matter is the authorship. 2389 Research is Dan Shapiro's group - the author of Kilroy, blip 10. Kilroy did not die of neglect; its author concluded the format was the problem and built a replacement, complete with dippin migrate and dippin validate-migration for moving existing lines across with parity checks. Assess, urgently: if this gets adopted, blip 1 moves.

4
Python20 starsstrongDMApache-2.0

An eval for spec-following, and the most directly teachable thing anyone has published. Most coding benchmarks ask whether an agent can fix a bug; this one asks whether it can read a 2,000-line natural-language specification and build a conformant system from nothing, scored granularly against a Definition-of-Done checklist grouped by spec section - so you can see exactly where a model excels and where it breaks down.

The best part is a caveat its authors published alongside it: scores are not valid for ranking pending burn-in runs to characterise run-to-run variability. A probabilistic system needs its variance measured before its numbers mean anything. Most teams ship the leaderboard first and discover this later.

5

Generated assembly lines

Assess

Authoring the line is itself a job you can hand to a machine. Kilroy's attractor ingest turns an English requirements document into a DOT graph; nlspec-to-dot unbundles the same capability as a standalone Ruby tool. Only two implementations built it, which is surprising given how obviously it follows from the pattern.

Assess because the failure mode is unexamined: nobody has published what happens when the generated graph is subtly wrong, and a bad assembly line fails expensively - every machine on it burns tokens before anyone notices the topology was the problem. Generate it, then read it. It is a small file; that is the entire point of blip 1.

6

Node shape as type discriminator

Hold

Across at least ten ports, the type of a machine is encoded in its Graphviz shape: Mdiamond is the entry, box a doer, diamond a conditional, parallelogram a fan-out, trapezium a fan-in join, hexagon a human-escalation gate, doubleoctagon a manager loop, Msquare the exit. The consistency is remarkable and it makes lines render meaningfully in any Graphviz viewer.

It is on Hold anyway, and this is the radar's most uncomfortable placement. Convergence proved the vocabulary was real - every serious factory needs these eight machine types. It did not prove the notation was good. Encoding a semantic type in a visual attribute means a typo produces a silently wrong graph rather than an error, and it is precisely what Dippin was built to stop. Keep the taxonomy; expect to stop spelling it in shapes.

Autonomous factories

18 blips · no human in the loop

Everything here runs without a person in the conversation. Two sub-families sit inside it. The Attractor ports answer “is it done?” structurally, with a validator machine on a graph edge. The software-factory projects answer it statistically, with a holdout set the doer never sees and a judge scoring satisfaction to convergence. Thirty-one genuine Attractor ports exist; the ones blipped here carry a distinct lesson. The shape of the quadrant is the story - one blip in Trial, ten in Assess, seven on Hold.

7

Fabro

Trial
Rust · MIT1,485 starsbacked by qlty.sh8-10 commits/day

The only entry with a company behind it and the only one shipping daily. Assembly lines are DOT files extended with a model_stylesheet block - CSS-like selectors routing machine classes to different models and reasoning-effort levels, which is the most elegant idea on the radar. Machines run in Daytona cloud sandboxes with SSH and live preview into the running box, every stage takes a git checkpoint, and a REST API streams durable events. One dependency-free binary, five install paths.

Its lineage is the correction this edition makes. Fabro did not take inspiration from Attractor at arm's length; it is the successor to one of the ports (blip 11), written by the same person. Trial not Adopt purely on age - ten weeks of public life is not a track record, and the sandbox and durability claims are documented rather than independently verified here.

8

F#kYeah

Assess
F# / .NET 1013 stars~1,020 testslast commit 2026-08-03

The most disciplined port in the set, and almost nobody has noticed it. Single compiled binary, checkpoint after every stage with resume, fan-out with fan-in consolidation, a unified client across three providers kept current with each model release, and roughly 17 reference assembly lines rather than one toy example.

The reason to assess it is a 208-test conformance suite validating behaviour against the spec. If you have ever wondered how you would write an eval for “did I implement this prose correctly”, this is the best worked answer available. No sandboxing, though - shell machines run against the host, which is blip 34.

9

Dark Factory

AssessNew
Python 3.13 · MIT7 stars100 commits in 10 dayspushed 2026-08-10

Not on strongDM's own list, and the second-most-active port in existence. Its README states the pattern better in one line than anyone else has: it shifts the unit of durability from ephemeral agent logs to a version-controlled process graph. It is also the only port that borrows the rival family's verification idea, keeping holdout scenarios in a physically separate repository so the doer cannot reach them.

Worth watching for a reason beyond its code: ten weeks in and still accelerating is something nothing else in this quadrant managed. If it holds that pace it moves to Trial next edition. Note too that strongDM's list links a DeepCreative/dark-factory that 404s - probably this project under an old owner.

10

Kilroy

HoldMoved out
Go216 starsby Dan Shapirolast commit 2026-04-27

The most production-shaped port after Fabro, and the one Fabro cites as reference. Four verbs: ingest generates a DOT line from English, validate checks it semantically, run walks it, resume recovers from logs, from a purpose-built run database, or from the run's own git branch. Each machine executes in its own git worktree and commits on completion - blip 29, and the cheapest real isolation story anyone built.

On Hold because it stopped in April, but read the reason before you conclude anything about the pattern: its author did not lose interest, he built Dippin instead. This is the rare radar movement with a documented cause.

11

brynary/attractor

HoldMoved out
TypeScript / Bun · Apache-2.024 starsarchived 2026-03-18

The highest-starred port that strongDM's own list omits, and Fabro's direct ancestor. A Bun monorepo of exactly three packages - unified-llm, coding-agent, attractor - which is the three-layer convergence in its purest form, arrived at independently by the person who then went and built the field leader. Archived with a redirect: “The ideas here have evolved into Fabro, a production-ready software factory built in Rust.”

Hold, obviously. Blipped because reading it beside Fabro shows a weekend port becoming a product, step by step, and because its omission from the canonical list is a lesson in itself.

12

attractor-c

HoldWorth reading
C1111 starsone squashed commit2026-02-17

Written by Justin McCarthy, strongDM's co-founder and the spec's author - which makes it the tiebreaker when the other ports disagree about what a paragraph meant. Pure C11 with no dependencies beyond libcurl and pthreads, compiling to a static library plus one binary, implementing the full spec surface with each layer mirrored by its own spec file. It even ships self-referential lines that run Attractor against its own spec to check compliance.

One commit, never touched again. Hold as software; canonical as documentation.

13

attractor-rb

HoldWorth reading
Ruby3 stars4 commits, 3 days2026-02-23

Four commits total, and better spec discipline than projects a hundred times its size. It ships a CONFORMANCE.md pinned to a specific upstream commit that enumerates exactly one intentional deviation and seven unimplemented upstream capabilities by name - blip 31, and the standout example of it. Five-phase execution, 13 lint rules before anything runs, and the same CSS-like per-machine model stylesheet Fabro has, arrived at independently.

14

attractor-pi-dev

HoldWorth reading
TypeScript23 starstwo-day burst2026-02-12

Notable for honesty and for one genuinely novel mechanic. The README has a section titled “How this differs from the spec” naming its exact gaps - the manager loop is coded but not wired in, so it no-ops; resume works internally but has no CLI flag. Its fan-in machines can rank parallel candidate branches with a model prompt, falling back to a heuristic, which is the only place anyone applied model judgment to joining rather than routing. Project-doc discovery walks from git root to cwd within a 32KB budget: selective inclusion made explicit.

15

The February cohort

Hold
~22 portsFeb-May 2026mostly solo

One blip for the long tail: the Python, Go, Kotlin, Scala, Tcl, PHP, C#, TypeScript and Elixir ports that appeared in a burst, worked, and stopped. Some are good - attractor-phoenix has 100+ commits and a real pull-request workflow on the BEAM, the most natural runtime fit anyone found, and zero stars to show for it. samueljklee is the only port that took the permission model seriously, with a shell deny-list, path confinement and injection prevention.

Together they are why the Adopt ring is nearly empty: cheap to start, cheap to demo, and abandoned the moment the author's own itch was scratched. The difference between this cohort and blip 7 is not a better idea. It is sustained investment.

16

ElasticClaw

AssessNew
Go · Apache-2.039 starspushed 2026-08-10

Turns issue-tracker events into governed workflows: provisions an isolated workspace, injects issue context, mints scoped short-lived GitHub credentials, opens the PR, watches review and CI, tears everything down. Its own README makes the best case in this quadrant - “remote coding agents give you a shell; ElasticClaw gives you the workflow around it.” The best permission model example on the radar, and the only project treating credential scope as a first-class factory concern.

17

Taskplane

AssessNew
TypeScript210 starspushed 2026-07-18

Four machine types - supervisor, worker, reviewer, merger - with full worktree isolation, dependency graphing across parallel lanes, a file-based mail system so machines can talk to each other, and a local dashboard. Cross-model review is built in rather than bolted on: model diversity used deliberately as a correctness mechanism.

18

fspec

AssessNew
TypeScript · MIT79 starson npm

Makes Gherkin acceptance criteria the contract the factory works against, with coverage tracking linking code back to business rules and a checkpoint system for safe experimentation. Its diagnosis of the problem is worth quoting to any team new to this: agents lack “the infrastructure that professional developers take for granted” - no way to force adherence to acceptance criteria, no TDD guardrails, no workflow state.

19

OctopusGarden

AssessNew
Go55 starspushed 2026-03-18

The clearest statement of this family's thesis, and honest about its lineage - it credits strongDM's Software Factory and Dan Shapiro's five-levels framing by name. Its own words: “scenarios are a holdout set. The coding agent never sees them during generation. An LLM judge scores satisfaction 0-100, not boolean pass/fail. This prevents reward hacking.” That is blip 28, put more precisely than anyone else manages.

20

SWE-AF

AssessNew
Python · Apache-2.0969 starspushed 2026-08-10

The largest thing here by stars - an autonomous engineering-team runtime built on the AgentField platform, in public beta. Blipped mainly for scale calibration: it has more stars than every Attractor port combined except Fabro, and almost nobody discussing Attractor mentions it. The two conversations barely overlap.

21

Fluent

AssessNew
Rust · Apache-2.072 starspushed 2026-08-07

The only project here that treats learning across runs as architecture. Agent traces, production logs, user feedback and team vision become Observations; a scheduler routes work items through Writer, Tester, Reviewers and a Learner; review findings return to the Writer and accumulated Expertise guides future work. Every other factory in this survey starts each run from zero.

22

darq

AssessNew
Rust · MIT9 starson crates.io

Takes a GitHub issue and ships the merged PR, then runs scenario-driven testing through three distinct validator personas - junior, senior, maintainer. That is perspective-diverse validation rather than redundant validation: three lenses find different classes of problem, where three identical reviewers mostly agree with each other. Every run extracts patterns into a learning store.

23
Go · MIT158 starspushed 2026-08-10

The one project that treats a factory as something you operate rather than something you run. Its dashboard leads with execution throughput, reliability, cycle time, queue depth and worker health - manufacturing metrics, applied to software production, which is closer to the spirit of the metaphor than anything else here. Local-first: the operator API accepts loopback only.

24

Repos named dark-factory

Hold

Not a project - a warning about the search term. Two hundred and seventy-eight repositories match, and the great majority are empty scaffolds, one-day experiments, or landing pages. Several are README-only with zero bytes behind them. The name has become a genre signifier rather than a description, so treat a match as the beginning of due diligence rather than the end of it. Three candidates in this survey were eliminated by a thirty-second look at their file listing; the curated list that started this research had not done that.

Supervised methodologies

8 blips · the human keeps the decisions

The same problem, governed the other way. These encode the SDLC as skills - markdown files stating a goal, steps, criteria for done, and when to escalate - which an interactive agent reads and follows while a person signs off between phases. No assembly line, no orchestrator picking branches; the human is the orchestrator, and the process is the artifact. Attractor's founding premise is that nobody is in the loop. This family's premise is that somebody must be. Note the adoption gap before you weigh them: the projects below carry roughly 450,000 GitHub stars between them, against about 2,000 across every Attractor port ever written. That is a fact about attention, not about correctness, and the two are worth arguing about separately.

35

Superpowers

AdoptNew
MIT270,524 stars24,171 forksby Jesse Vincentpushed 2026-08-08

More stars than the Linux kernel, and roughly twice Claude Code's own. It installs into eleven different harnesses - Claude Code, Codex, Cursor, Gemini CLI, Copilot CLI, OpenCode, Antigravity and more - which makes it the only thing on this radar that is genuinely harness-agnostic in practice rather than in principle.

The process it encodes will look familiar from the opposite quadrant: it refuses to start coding, teases a spec out of the conversation, shows it back in chunks short enough to actually read, turns the signed-off design into a plan written for “an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing”, then runs subagent-driven development across the tasks with review between each. Red/green TDD, YAGNI and DRY are enforced rather than suggested. Skills trigger automatically on intent, so there is nothing to remember.

That last stage is the interesting part for this radar: once the plan is agreed it dispatches machines and supervises them, running unattended for hours. It is not the opposite of a factory so much as a factory with the human moved to the front, and it is the clearest worked example anywhere of a skill in the course sense - process encoded once, task supplied at invocation.

Use when

You want your team working the same way tomorrow without building anything. Installation is a plugin command, the cost of abandoning it is deleting a directory, and it is the shortest path from “we should be more disciplined with agents” to actually being so. Read its plan-writing skill even if you adopt nothing else - the junior-engineer framing is the single best prompt-design idea in this survey.

36

Spec Kit

TrialNew
Python · MIT126,182 starsby GitHubpushed 2026-08-10

GitHub's own answer, and the institutional heavyweight here: “define what to build before building it, with any AI coding agent.” Ships a specify CLI, a ready-made spec-driven process you can replace with your own, extensions and presets, and role-based bundles so a whole organisation can standardise rather than each engineer improvising.

Trial rather than Adopt because it asks more of you than blip 35 does. The process is heavier and more prescriptive, the artifacts are more formal, and adopting it is a team decision rather than an individual one. That weight is the point if you are trying to get thirty engineers working the same way - and overhead if you are trying to get three.

Use when

The problem is organisational consistency rather than individual discipline, and you need something with a vendor's name on it to get it past a review board. Also the natural pick if you are already deep in GitHub's tooling.

37

BMAD Method

TrialNew
JavaScript51,751 starsnpx bmad-method installpushed 2026-08-10

“Breakthrough Method for Agile AI Driven Development”, and the one that takes the widest view - it covers what to build and how it holds together, not only the code. Its distinguishing idea is right-sized process: small changes go straight to build, complex work gets depth, and the same method is meant to cover a weekend prototype and a system with years of history. A Clarify / Plan / Build-and-verify / Learn loop, entered at whichever point matches the work.

Its pitch is the sharpest statement of this quadrant's whole thesis: coding assistants are effective at implementation, but they turn unstated assumptions into code. Everything here exists to make the assumptions explicit before they harden.

Use when

Your work varies widely in size and a single fixed pipeline would either strangle the small changes or under-serve the large ones. Also the best fit if you are bringing agents to an inherited codebase, which it treats as a first-class case rather than an afterthought.

38

Conductor

AssessNew
Python · Apache-2.03,689 starspushed 2026-08-11

Spec-driven development as a plugin, from the Gemini CLI extensions org, targeting Antigravity and Claude Code. Worth assessing as the cross-vendor data point: the same shape arrived at independently by Google's tooling org, which is corroboration of the pattern rather than of any one implementation.

39

MoAI-ADK

AssessNew
Go · Apache-2.01,162 starspushed 2026-08-11

Calls itself an agentic development harness rather than a methodology, and sits closest of anything in this quadrant to the opposite one: SPEC-driven plan/run/sync with explicit quality gates between stages. The gates are the interesting part - a supervised process that has started to formalise its transitions is converging on what an assembly line does, from the other direction.

40

Agent OS

AssessNew
Shell · MIT5,250 starslast push 2026-05-05

Attacks a problem the others mostly assume away: where do the standards come from? It extracts patterns and conventions from your existing codebase into documented standards, then injects the relevant ones based on what is being built. That is RAG in the course sense - dynamically shaping the prompt with the context that matters - applied to house style rather than to documentation.

Assess rather than Trial because it has been quiet since May while the rest of this quadrant ships weekly. The standards-extraction idea is worth stealing regardless of whether the tool survives.

41
1,253 starslast push 2026-03-26

An orchestrator plus nine specialised sub-agents doing spec-driven development. Blipped as the quadrant's cautionary case: a thousand stars and five months of silence. The supervised family has the same abandonment problem as the autonomous one - it is just hidden by the size of its winners.

42

Stacking rival methodologies

HoldNew

Every framework here installs instructions that fire automatically on intent, and each encodes its own opinion about what should happen when you say “build me X”. Install two and they compete for the same trigger, silently: you get one methodology's planning stage feeding another's implementation stage, with neither's criteria for done applied end to end.

A search for spec-driven agent frameworks returns dozens, most of them a few months old, all solving the same problem with incompatible vocabulary. Pick one deliberately and delete the others. The cost of the wrong choice is small; the cost of three simultaneous choices is a process nobody can reason about.

Techniques

11 blips · 4 in Adopt

The quadrant that pays, and the one that survives whichever way the governance argument goes. Most of these were re-derived independently by implementers who had never spoken; several were arrived at from both directions at once. None of them requires you to depend on a stranger's repository.

25

Doer-validator loop, bounded

Adopt

Separate the machine that produces work from the machine that checks it, feed findings back, and repeat until the validator has nothing significant left to report. The separation is the point: a model that has just produced an answer is bad at finding its own errors in it, whereas a validator that did not write the work has nothing to defend.

The bounded half is what implementers learned the hard way and what most tutorials omit. A doer and validator can oscillate, each pass introducing a new problem, so every serious port caps the iteration count. Set the cap even though you expect to settle in two or three passes.

26

Per-machine checkpoint and resume

Adopt

Nearly every implementation independently built durable per-machine checkpointing so an interrupted multi-hour run resumes rather than restarts. Mechanisms vary - git worktrees plus a run database in Kilroy, a git checkpoint per stage in Fabro, SQLite in soulcaster, plain JSON files in most others - but nobody who built something real skipped it.

That unanimity is the argument. Long-running, cost-bearing lines make idempotency a load-bearing requirement of the problem rather than a nicety you add later. Design for restartability from the first commit; retrofitting it means unpicking every assumption about state.

27

Human escalation on irreversible actions

Adopt

Attractor's entire pitch is that no human is in the loop. A clear majority of implementers added an optional human-approval machine anyway - Fabro's hexagon gates with accelerator keys, attractor-php's wait.human with a POST /answer endpoint to unblock it, attractor-scala's gate with an --auto-approve escape, and attractor-ruby's, flagged in its own README as a deliberate divergence from the spec.

Read that as engineering rather than hypocrisy: autonomy claims get walked back the moment someone builds a thing they want to trust. The useful question is not whether to have gates but which machines have a side effect you cannot undo - and whether each of those has one.

28

Holdout scenarios with a judge

AdoptNew

Hold back a set of verification scenarios the doer never sees during generation, and have a judge score satisfaction on a continuous scale rather than pass/fail. Borrowed wholesale from machine learning, where it is simply a holdout set, and it is the strongest single idea on this radar.

It exists because the doer-validator loop can be gamed by the thing it is checking: an agent that can see the test can satisfy the test. In course terms this is an external selection channel - a check whose mechanism and context sit outside the doer's reach - and it is the direct answer to overfitting evals. Arc goes furthest, keeping holdout scenarios the implementer cannot read; Dark Factory (blip 9) puts them in a separate repository entirely. Adopt this even if you adopt nothing else here.

29

Git worktree per machine

Trial

Run each machine in its own git worktree and commit on completion. Kilroy does this, and it is the cheapest real isolation available: you get parallel-safe execution, a literal inspectable audit trail of what each machine changed, and rollback for free, using a tool already in every repository.

Trial rather than Adopt because it is proven by exactly two implementations at meaningful scale (Kilroy and Taskplane), and because worktrees have sharp edges - submodules, hooks, and anything assuming a single working directory. Still: if you are choosing between this and nothing, it is not close. See blip 34 for what nothing looks like.

30

Per-machine model routing

Trial

Different machines on the same line want different models. Fabro expresses this as a model_stylesheet with CSS-like selectors assigning model and reasoning effort by machine class; attractor-rb arrived at the same stylesheet idea independently; most other ports expose per-machine model config more plainly. Separating the routing policy from the graph topology is the elegant part - you can retune cost without touching the line.

This is model tiers and model routing falling naturally out of the architecture, and it is the cheapest cost lever available: a triage machine does not need a flagship model.

31

Documented spec-drift file

Trial

When you implement someone else's specification, write down exactly where you diverge and why, pinned to the upstream commit you read. attractor-rb's CONFORMANCE.md is the model: one intentional deviation with its rationale, seven unimplemented capabilities named individually, all against a specific February commit. attractor-pi-dev does a lighter version in its README; F#kYeah enforces the same thing executably with a conformance suite.

Everyone who replaced model-judged routing with a deterministic algorithm had a defensible reason. The ones worth modelling wrote it down. Silent drift is the failure mode; documented divergence is engineering.

32

Deterministic edge resolution

Trial

Resolve which edge to follow with an auditable algorithm rather than a model call. Four ports - attractor-tcl, attractor-scala, attractor-ruby and attractor-software-factory - independently converged on the same five steps: exact condition match, then outcome-labelled edge, then suggested node, then edge weight, then lexical tiebreak. Four people, no coordination, same algorithm.

The motive was always auditability: control flow you can explain after the fact, and reproduce. Trial rather than Adopt because it is a genuine trade - you give up the expressiveness that made blip 33 attractive in the first place.

33

Model-judged edge routing

Assess

The spec's own mechanism: edges carry natural-language conditions and a model decides at runtime which one was satisfied. This is the semantic interface applied to control flow, and it is what makes the pattern feel like more than a workflow engine - transitions can express things no boolean can.

Assess, because the field split on it. Roughly a third of implementers replaced it outright, and their stated reason is hard to argue with: a routing decision you cannot reproduce is a routing decision you cannot debug. Nobody has published a comparison of the two approaches on the same workload, which is the experiment most worth running and nobody has run it.

34

Unsandboxed host execution

Hold

The single sharpest quality signal here, and the majority position. Most implementations run shell commands and file edits directly against the host with no isolation whatsoever - while also running git commit. Arc documents no sandboxing while executing typecheck, test, lint and commit. attractor-pi-dev has process-group signal handling, which is process management, not isolation.

Fine for a class exercise. Disqualifying for anything pointed at a repository you care about, and the line between a demo and a tool. The fix is not exotic: blip 29 costs an afternoon.

43

The skill as the unit of process

TrialNew

Encode the process once, in a markdown file stating its goal, its steps, its criteria for done and when to escalate, and supply the task at invocation. “Here is how we review a pull request” lives in the repository and improves through pull requests like anything else; “review this pull request” is what you type. Crystallised prompt engineering, versioned.

Both quadrants converged on it from opposite directions. The autonomous family calls it a node prompt and attaches it to a machine on the assembly line; the supervised family calls it a skill and triggers it on intent. Same artifact, same benefit: the process stops living in whoever happened to write the prompt that day.

Trial rather than Adopt only because the discipline is newer than the idea. A skill that states its goal but not its criteria for done is a prompt with extra steps, and most published skill libraries are still that.

How this was made

and where it might be wrong

Nineteen research machines fanned out in parallel over one repository each, returning structured output against a fixed schema; one machine synthesised the comparison. Roughly 864k tokens, six and a half minutes. Two later passes - plain GitHub API searches, no machines - found fourteen unlisted ports, Dippin, the software-factory family, and then the supervised-methodology quadrant, which is larger by adoption than everything else on the radar combined.

Known limits of the evidence
  • Two tiers of confidence. Seventeen ports were researched in depth. Everything in the platforms quadrant, plus the unlisted ports, was verified only by repository metadata and README. That is exactly why no platform blip sits above Assess - the ring reflects what we actually know, not what the projects claim.
  • The supervised quadrant is the least researched. Those eight blips come from repository metadata and README text only. They are on the radar because leaving them off implied the autonomous family was the whole field, which is false - not because they were studied to the same depth as the Attractor ports.
  • Nothing was cloned or run. Every functional claim - sandboxing, resumability, parallelism - comes from documentation. Read these as documented, not verified working.
  • Star counts are directional. Most were read from the GitHub API on 10 August 2026; some in the profiled set came from rendered pages. Contributor graphs failed to load for the majority of repositories, so “solo project” usually means “one author visible in the commit log”.
  • Ring placement is a judgement, and an opinionated one. A radar's value is that someone was willing to be wrong in public. The placements most likely to be wrong: Graphviz DOT in Adopt (blip 3 is a serious argument against), Fabro held out of Adopt purely on age, and Superpowers in Adopt on the strength of maturity and reversibility rather than anything this survey verified by running it.
  • The fan-out missed what it was not pointed at. Nineteen machines each got one URL and did excellent work inside that box; not one asked whether the list was complete. The unlisted ports, Dippin and the 278-repo second family all came from a minute of searching that was not in the original plan. A completeness pass is the difference between a survey and a summary of someone else's list.