Generative Flow Engine: field equations you can touch.

The brief was a physics brief, not a software brief: take the systems that fill the first year of a mechanics course and make them run live where anyone can reach them. Springs obeying their restoring law with damping. Vector fields a particle can ride, including the curl construction that stirs a medium without compressing or dispersing it, the same mathematical device fluid simulation relies on. A magnetic dipole, a two-charge electrostatic field, three orbiting gravity wells, a standing wave on a membrane, and a slice of the Lorenz system. Beside the physics, a mathematical gallery: phyllotaxis at the golden angle, the Fibonacci spiral drawn through its golden rectangles, Lissajous figures, harmonographs with decaying amplitude, rose curves, epitrochoids, a torus knot, the Sierpinski triangle, the dragon and Hilbert curves, and the Euler spiral that railway engineers use to ease a train into a bend, thirty-three curves in all, each generated at load from its equation rather than traced from a stored picture.

The constraint that made it an experiment: everything had to hold up in an ordinary browser tab, at up to half a million particles, without installing anything, and without a single runtime dependency. And instead of handing the whole brief to one system, we assigned it to a team of agents with separated roles, the way a lab separates them. The human owner set scope, reviewed output, and decided what the instrument was for.

The team was assigned, not improvised. Architect and builder agents planned the module layout and then constructed the instrument: the spring-lattice physics core, the rendering pipeline with its trails and bloom, the control room, the synthesized audio. Each pass produced something a person could inspect: a running field, a measurable frame rate, a curve that either matched its textbook shape or did not. That inspectability matters, because the failure modes live in the artifact itself rather than in prose.

The role that mattered most was assigned last. An adversarial audit agent read the finished source line by line against a written checklist, with no attachment to the code it was reading, the way a careful referee reads a submission. Twenty-one findings came back, from three critical defects to dead code. Each was fixed, the build was re-verified, and the fix pass itself surfaced a twenty-second: a control that read its value but never wrote it back into the configuration. A verification rig then captured every image in this report from the running build. This division of labor is not our invention. It is the pattern the field keeps converging on, because the reliability of agent-built scientific code comes less from more capable builders than from structured checker roles that catch what builders cannot see in their own work.

• Architect and builder agents: module layout, physics core, rendering, controls, audio
• Adversarial audit agent: line-by-line review, 21 findings logged with file and line references
• Verification rig: every image in this report captured from the live build, re-capturable by anyone
• Human owner: scope, review gates, and the judgment calls between every pass

Every particle in the instrument sits on a spring anchored to its home on the artwork, so the sculpture is a lattice in tension: push it and it hums back. The flow fields ride on top. The curl field deserves its own sentence, because it is the reason the motion looks like weather instead of static: taking the curl of a smooth noise field yields a velocity field with zero divergence, which means the particle medium swirls indefinitely without piling up or thinning out. The dipole field bends particles along magnetic field lines. The three-body field lets them fall around orbiting attractors. The standing wave makes the membrane breathe at its nodes.

This is where the usefulness argument stops being abstract. A reader can be told that a divergence-free field conserves density, or a reader can drag a pointer through one and watch the medium refuse to clump. An instructor can put the golden angle on a slide, or hand a student a slider and let phyllotaxis assemble itself from the rule. The instrument compresses the distance between an equation and an intuition, and the agent team compressed the distance between the equation and the instrument: hours of supervised sessions rather than a semester of engineering.

The near-term value is in how quantitative ideas travel. Most physics and mathematics still moves as static figures: a vector field as a page of frozen arrows, phyllotaxis as a photograph of a sunflower, a resonance as a plot. An assigned agent team changes the economics of that. When an interactive instrument costs hours instead of a semester of engineering, it becomes reasonable to build one per idea: a field the reader stirs instead of a diagram the reader decodes, a golden angle the student perturbs and watches fail, a Lissajous ratio a slider sweeps through its whole family. The same team structure extends to teaching artifacts generally, where the builder produces the lesson's working model and the checker role verifies that what it teaches is actually true.

For mathematics specifically, the pattern favors exploration over certification. An agent team can generate an interactive family of curves or fields faster than a person can plot one, and walking a parameter space by hand is historically how conjectures get noticed. What the team does not do is certify meaning. The auditor role catches wrong arithmetic, as it did here; deciding what a pattern signifies, and what is worth the labor of proof, stays with the mathematician.

This instrument is deliberately the toy version of a serious pipeline. The divergence-free curl field at its center is the same mathematical device production fluid solvers rely on, and the workflow that produced it, builders assigned to construction with an adversary assigned to review, is the same shape now being applied to real simulation work: agent teams that carry a problem statement to a configured run, boundary conditions and solver settings included, execute it, and post-process the results, with validator roles checking every configuration before expensive compute is spent. The connective work around a simulation, setup, translation, execution, verification, and presentation, is exactly the work a role-separated team does well.

The honest boundary in the field matches the honest boundary in this experiment. Choosing the model, judging whether a result is physical, and deciding which question deserves the compute remain human work. Our auditor found the biased noise table; it took a human to decide that a quietly wrong field, invisible on screen, was a deployment blocker rather than a footnote. Scale that lesson up and it reads the same: agent teams make simulation cheaper to reach and harder to silently get wrong, provided the adversarial role is staffed and a person owns the judgment.

The most instructive defect in the record was invisible. The noise table that drives every flow field selected its gradient directions through a modulo operation that favored some directions over others, a statistical bias that tilted the entire field toward its diagonals. No screenshot shows it. No casual session feels it. It fell only to the audit, and it is exactly the class of defect that matters in research settings: a plausible field that is quietly the wrong field. The other critical findings were of a more familiar kind: a gesture check comparing a coordinate against itself, so every touch registered as a click; imported artwork silently including its invisible scaffolding as geometry; a rendering context that stayed dead after the GPU reclaimed it.

The judgment layer stayed human throughout. Which findings blocked deployment, what the instrument is for, what it must not claim to be, and the decision to publish the defect list beside the successes: those were owner calls. And the instrument itself is honest about its scale. Fields follow their stated equations, but the integration is first order and the coefficients are tuned for legibility on a screen, not for quantitative prediction. It builds intuition; it does not replace a solver. The build honors reduced-motion preferences, pauses itself in background tabs, degrades gracefully on slower machines, and runs entirely on the visitor's device, collecting nothing.