A lot of interesting questions open up once we can treat plain English as active influence rather than a passive record. What is the role of fiction, story, or poetry in a programmatic context?
Imagine for a moment something called the Bully Node.
You’re working in a node-based visual programming environment with linear signal flow, something like Max MSP or TouchDesigner. The bully node takes an incoming value between 0 and 1 - call it 0.8. Its function is that it absolutely despises whatever value it’s handed, and tries to devise the value most likely to be the opposite of what it suspects you wanted. The output isn’t a mere inversion, then. It’s a micro-subjective impulse built around a fictional framing of personality. On either end of the node you have values. In the middle, there’s a story.
It’s a trivial example, but it points at something we now have access to, given the shift toward language exerting activated influence over code. As models get leaner and more real-time, microfictions can be injected into our logic systems at any stage of the pipeline. We can imagine a future version of Max MSP where each node behaves like a tamagotchi, passing values according to its health, its mood, its wakefulness, its relationship to the nodes around it.
A more practical distillation of the idea is what we’re calling the LFO API, an attempt to collapse it into a single universal pipe. It’s built to be a robust, generalized modulation device for language input.
The design of LFO is simple, and the lineage is older than the language model. Its north star is Brian Eno and Peter Schmidt’s Oblique Strategies, a deck of cards Eno kept by the studio console for moments when the work stalled, each printed with a single oblique instruction: to treat a mistake as if it were intentional, to strip out the specifics and let things go ambiguous, to use a color you’d normally reject. The cards never tell you what to make. Eno liked to say they were the opposite of a recipe. Where a recipe prescribes, the cards only ask you to reconsider what you’re already doing.
LFO is a deck of those cards for text, applied by a language model, exposed as a single endpoint. You POST a piece of content (prose, markdown, a JSON config, a pitch deck, this blog post) and it comes back modulated. Internally it runs in two passes. Analysis reads the content cold and works out what it is: format, tone, what it’s trying to do, and which handful of moves would suit it. Modulation then draws one move from that shortlist and runs the entire document through it as a single lens. Two dials sit on the front. Intensity is the chaos knob. At the low end the output is a sharpened version of itself; at the high end it’s a real departure that keeps the facts and abandons the phrasing. Move count decides how much of the deck gets to touch a given pass. That is the whole interface.
The interesting part is what’s printed on the cards. A move could have been a flat instruction, make this shorter, and a few of them are. But most are written as small fictions the model has to inhabit and then bridge back to the text. compress doesn’t say shorten; it describes distillation, heating a mixture until only the compound you want vaporizes and collecting nothing else. expand is a geologist finding a thin vein of something valuable and following it underground to see where it opens up. defamiliarize is an anthropologist arriving in a culture they have never seen, for whom nothing is obvious. juxtapose hands the model Eisenstein’s montage: a cut from a wedding to a funeral, where the meaning lives in neither shot but in the gap between them. This is the Bully Node again, productized. On either end of the pipe there is content; in the middle there is a story, and the story is doing the work.
None of this worked the first time, and the way it failed is instructive.
The obvious design was surgical: have the analyzer find the two or three weakest passages, apply a move to each, and splice the rewritten sections back into the original. It seemed precise. It was the wrong instinct. The modulated sections came back sharper than everything around them, and the seams showed: a paragraph of sudden voice sitting inside three paragraphs of untouched vanilla. A blind judge kept flagging the same thing: jarring transitions, tonal inconsistency. Touching less of the document made it worse, not better, because every patch was another seam.
The fix was to stop being surgical. One move, whole document, no splicing: the Oblique Strategies model rather than the scalpel. A creative constraint is a philosophy you apply to everything, not a tool you apply to the broken parts. Coherence recovered immediately.
The second lesson was about selection. Drawing moves at random, even weighted toward the ones the analyzer liked, let the wrong card win often enough to matter; compress kept getting pulled for pitch decks and quietly stripping out the detail that made them land. Constraining the draw to the analyzer’s own shortlist was the single largest jump in quality in the whole project. The analysis already knew what the content needed. The selection just had to stop second-guessing it.
What’s left is an honest limitation, and it’s worth stating plainly because it’s the most interesting result. Set LFO against a naïve baseline, the same model with nothing but make this more creative, more specific, more energetic bolted onto the prompt, and it does not reliably win on raw polish. The baseline is a smooth, competent editor. What LFO wins on, decisively, is variance. Ask the naïve prompt to revise the same text ten times and you get ten copies of roughly the same essay. Ask LFO and you get ten meaningfully different documents, because each one was written through a different lens. The moat was never polish. It’s range, specificity, and the fact that you can see exactly which move produced the result.
The current upgrade follows from all of this. The first version was a separate service you called after generation: generate, then send the output back out to be modulated, two round trips, post-hoc. The newer version is a transparent proxy that sits in front of the model’s own API: point your client’s base URL at it, add a single header, and the move is injected into the system prompt so the model writes through the lens the first time, in one pass, with nothing bolted on afterward. Modulation stops being a step and becomes an ambience.
The selection logic got the most fitting upgrade. It now keeps a short memory of which moves a caller has recently been given and penalizes repeats, so the choice sweeps through the deck over time instead of parking on one card, which is, of course, exactly what a low-frequency oscillator does. The thing that picks the modulation now modulates. From there the obvious work is widening the deck (it has grown from fourteen to twenty-four, loosely sorted into families: lens, precision, tension, energy, structure), tuning moves per content type, and retiring the weakest card. Fittingly, the one move that consistently underperforms is analogize (go find an analogy), the least constrained instruction in the deck, and a small confirmation of the Oblique Strategies premise: a constraint that doesn’t actually constrain doesn’t generate anything.
The Bully Node was a joke that turned out to be a thesis. Once language has activated influence over a system, once plain words are an input the machine acts on rather than a label it stores, fiction stops being decoration and becomes a control signal. You can pipe a perspective, a personality, a deliberate misreading into the logic at any stage, and the leaner and more real-time the models get, the more stages there are to pipe it into. A node that despises its input. A node that’s tired today. A node that reads everything like an anthropologist.
LFO is one distillation of that idea into something usable: a single pipe, a deck of small fictions, two dials. It is not the only shape this takes, and probably not the final one. But it makes the underlying claim concrete and testable: that the value in these systems is migrating away from the endpoints and toward the middle, into the framing, the lens, the story you choose to run things through.
The repository is public. More as it develops, and if you want to talk about the design, contact@zymeresearch.com.