Synthace’s proof-of-concept dropped quietly: a biologist types “set up a serial dilution from 10 mM to 10 µM in eight steps,” ChatGPT translates that into a structured JSON protocol, and the Synthace planner executes it against actual lab robots. The video looks like magic. The architecture, drawn properly, is not.

←TODAY: Synthace’s ChatGPT-in-the-lab integration is a 2026 proof of concept, not GA — gated by a context-aware prompt and a JSON contract. →3012: Buildings, like cells, will be specified once in plain language and executed thousands of times against changing equipment — the brief becomes the artefact, not the model. Fulcrum: The interesting engineering is the layer between the language and the execution, not the language model itself.

Three boxes and two arrows

Here is the topology. Box one: ChatGPT, calling OpenAI’s GPT-3.5 API. Box two: the Synthace API, which plans biology workflows and simulates them against real equipment. Box three — the load-bearing one — is the Python middle layer holding a context-aware prompt: a prelude of JSON examples that constrain ChatGPT to emit a protocol in Synthace’s data structure, not English prose.

The two arrows matter more than the boxes. The forward arrow translates intent into structured action. The back arrow — and this is the cleverer move — catches errors from the planner (a 1000 mL volume requested in a 3 mL reaction, in Synthace’s own published example) and feeds them to ChatGPT, which silently corrects the protocol. Stephen Wolfram, quoted in Synthace’s own write-up, is right that LLMs cannot do trustworthy computation. The Synthace pattern accepts that and surrounds the LLM with a planner that can.

The pattern is older than the LLM

Architects already know this shape. Grasshopper sits between the designer’s intent and the geometry kernel. Dynamo sits between the BIM modeller and the Revit API. GhPython sits between Python and the Rhino runtime. In each case, the middle layer takes a forgiving human gesture, translates it into a strict downstream contract, catches the failures the downstream layer reports, and hides what it can. The novelty here is that the upstream layer is now a transformer, not a person — and PAZ’s concept panel on attention mechanisms explains why a 2017 architecture published for English-German translation ends up commanding pipettes. AlphaFold 2 in 2020 made the bridge between attention and biology public; Synthace in 2026 made it operational.

Atelier: The PAZ-GPT and PAZ Grasshopper↔Archicad Library stack runs exactly this topology — natural-language brief on top, JSON-or-equivalent structured layer in the middle, Archicad and Grasshopper at the bottom, errors looping back. When we build the next slice of that library, the part to engineer obsessively is not the prompt and not the executor — it is the validator and the error-feedback arrow. That is where credibility lives. Without it, the system gives you a roof you cannot pour.

Hack: This Hack teaches you to wrap a model call in a planner-style feedback loop — the exact pattern under Synthace. The medium is Python and the domain is Workflow: one prompt, one validator, one retry, no human in the loop until the budget runs out.

def plan(brief, err=None, tries=2):
    msg = brief if not err else f"{brief}  Fix prior error: {err}"
    proto = json.loads(call_llm('Return JSON {"steps":[{"vol_ml":0}]}', msg))
    over = sum(s["vol_ml"] for s in proto["steps"]) - 3.0
    return plan(brief, f"over by {over} mL", tries-1) if over > 0 and tries else proto

Swap the vol_ml ceiling for a max_span_m on a beam, or an LOIN level on an IFC export, and you have the same loop on the AEC side. The contract changes; the topology does not.

The dependency graph nobody draws

One systems note before the move. Synthace’s POC has at least three single points of failure stacked on top of each other: OpenAI’s API (rate-limited and not portable), the prompt template (one bad JSON example and the planner returns garbage), and the JSON contract itself (the moment Synthace’s data structure changes, every prompt rots). Researchers covered by South Carolina Public Radio last week were already asking whether AI-driven labs should be allowed to outsource this much to opaque pipelines. Any AEC office building a similar stack should draw its own dependency graph this week — not the architecture diagram, the dependency graph — and find the third single-point it didn’t know it had.

El Takeaway de PAZ

Stop talking about “ChatGPT for X”. The interesting work is the three-layer cake around the model: a context-aware prompt that constrains it, a structured execution layer that runs it, and an error-feedback arrow that closes the loop. If your office is sketching an LLM-driven workflow for Bauleitung or LV-Erstellung this quarter, draw the three boxes and two arrows on actual paper before you write a single line of code. The middle layer is the one that decides whether your system ships.