📄 bioengineering

Coding Agents as a Mechanism for Formalizing and Transferring Domain Knowledge in DNA Origami Design

This paper demonstrates how a coding agent can formalize and transfer DNA origami design expertise by converting human domain knowledge into repeatable text-file instructions, enabling autonomous execution of complex design pipelines, parametric scaling, and molecular dynamics simulations.

Original authors: Fu, D., Ke, Y.

Published 2026-04-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Fu, D., Ke, Y.

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ⚕️ This is an AI-generated explanation of a preprint that has not been peer-reviewed. It is not medical advice. Do not make health decisions based on this content. Read full disclaimer

Imagine you are trying to build a complex structure out of LEGO bricks, but instead of snapping them together with your hands, you have to write a computer program to tell the robot arm exactly where to put every single brick.

In the world of DNA origami, scientists fold a long strand of DNA (the "scaffold") into specific shapes using hundreds of tiny helper strands (the "staples"). Doing this manually is like solving a massive, 3D jigsaw puzzle where the rules change depending on the shape. If you want to make the box slightly bigger or add a hole in the middle, you often have to completely redraw the whole puzzle, a process that is tedious, prone to human error, and requires years of specialized training.

This paper introduces a new way to do this using a "Coding Agent"—a smart AI that doesn't just chat with you, but actually writes and runs the computer code needed to design these DNA structures.

Here is the story of how they taught this AI to be a master DNA architect, explained through simple analogies:

1. The Problem: The "Menu" Didn't Work

At first, the researchers tried to give the AI a simple menu of buttons to press (like "add a staple" or "move a strand").

The Analogy: Imagine asking a chef to cook a complex meal by only letting them choose from a list of pre-defined actions like "chop," "fry," or "stir." The chef might know how to chop, but they don't know when to chop or what to chop to make a specific dish.
The Result: The AI failed. It couldn't figure out the hidden rules of DNA folding (like which strands connect to which) because those rules weren't written in the menu. It was like trying to drive a car by only pressing buttons without understanding the steering wheel or the road.

2. The Solution: Giving the AI the "Blueprints"

The researchers changed tactics. Instead of giving the AI a menu, they gave it access to the source code—the actual "blueprints" and "instruction manuals" of the design software (caDNAno).

The Analogy: Now, instead of just pressing buttons, the AI is an apprentice who can read the architect's original notebooks. It can see why the bricks go where they do. It can write its own scripts to move the bricks, rather than waiting for a human to tell it exactly which button to push.

3. The Learning Curve: Trial, Error, and "Aha!" Moments

Even with the blueprints, the AI didn't know the "unwritten rules" of DNA origami. It had to learn through a process of trial and error, guided by a human expert.

The "Layer" Confusion:
- The Mistake: The AI was told to build a "2-layer" structure. It built a 4-layer mess because it counted rows of bricks instead of physical layers.
- The Fix: The human said, "No, in DNA land, one physical layer is actually two rows of bricks." The AI wrote this rule down in its permanent notebook. Next time, it got it right immediately.
The "Hole" in the Middle:
- The Mistake: When asked to build a box with a hole in the middle, the AI tried to use the same rules as a solid box. The DNA strands got tangled and broke.
- The Fix: The human showed the AI a specific pattern for how strands should turn around a hole. The AI learned this pattern, saved it, and then applied it to any size of hole it was asked to build later.

4. The Superpower: Turning Knowledge into Tools

The most exciting part of this paper isn't just that the AI learned to build one shape. It's that every time the AI made a mistake and learned the fix, it turned that lesson into a reusable tool.

The Analogy: Imagine a student who fails a math test because they forgot to carry the one. Instead of just fixing that one problem, they write a "Carry-the-One Checklist" and stick it on the wall. Now, anyone (or any other robot) can use that checklist to never make that mistake again.
The Result: The AI created a "Safety Net" (a verifier script) that checks every design for these specific errors before it's even built. It also created "Templates" that allow it to instantly resize a design from small to huge without breaking it.

5. The Final Achievement: The Autonomous Architect

By the end of the process, the AI could:

Listen to a human: "Build a 20nm by 40nm box with a hole in the center."
Do the math: Calculate exactly how many DNA strands are needed.
Build it: Write the code to design the structure.
Test it: Run a virtual simulation to see if it holds together.
Fix it: If the simulation shows a wobble, the AI knows exactly how to tweak the code to fix it.

Why This Matters

This paper suggests a new future for science. Instead of every scientist having to re-learn the complex rules of DNA folding from scratch, they can use an AI that has already "read the books" and "learned from its mistakes."

The AI acts as a translator. It takes the messy, intuitive knowledge of a human expert (who knows how to fold DNA) and turns it into clean, repeatable computer code. This means that once a difficult design challenge is solved, the solution is saved forever, making it easier for the next person to build something even more complex.

In short: They taught a robot to read the instruction manual, learn from its own mistakes, and then write its own instruction manual for the rest of us.

1. Problem Statement

Designing DNA origami structures is a labor-intensive, iterative process that requires re-routing scaffold strands, re-placing staple strands, and verifying structural integrity for every parameter change. While the operational tools (e.g., caDNAno) exist, the domain knowledge required to use them correctly—such as honeycomb lattice geometry, crossover parity rules, and scaffold routing patterns—is not encoded within the software. Instead, this knowledge resides in human expertise, tutorials, and lab conventions.

Current automated design tools suffer from a lack of continuity; they address specific shape classes or subtasks in isolation, forcing designers to learn disparate interfaces. Furthermore, standard Large Language Models (LLMs) used as "tool-calling agents" (which select from predefined APIs) fail at complex multi-step design tasks because they cannot resolve contextual constraints (e.g., helix parity, crossover directionality) that are invisible in the API schema.

2. Methodology

The authors propose a coding agent architecture (specifically using Claude Code) that interacts with DNA origami design tools differently than traditional tool-calling agents.

Architecture: Instead of relying on a predefined API, the agent has direct access to the source code of the design tool (caDNAno) and external simulation tools (tacoxDNA, oxDNA).
Workflow:
1. Code Reading: The agent reads the source code to understand internal data models, available methods, and file structures.
2. Script Generation: The agent writes and executes Python scripts to manipulate design files, convert formats, and run simulations.
3. Iterative Correction Loop: When the agent fails (due to missing domain knowledge), a human designer provides an explicit correction. The agent then formalizes this correction into persistent artifacts (verifier functions, pipeline scripts, and documentation) rather than just fixing the immediate error.
4. Autonomous Execution: Once knowledge is encoded, the agent autonomously executes the full pipeline: design generation $\rightarrow$ verification $\rightarrow$ staple placement $\rightarrow$ format conversion $\rightarrow$ molecular dynamics (MD) simulation.

3. Key Contributions & Technical Findings

A. Comparison of Architectures

The study demonstrates that tool-calling agents achieve 0% success on multi-step design tasks (e.g., scaffold routing) because they cannot infer the "why" behind operations or compose complex sequences from fixed schemas. In contrast, code-generating agents succeed by reading source code to discover undocumented methods (e.g., setConnection3p/5p for preserving strand connectivity) and composing novel workflows.

B. Formalization of Invisible Domain Knowledge

The core contribution is the mechanism for converting implicit human expertise into explicit, machine-executable protocols. The authors identified and resolved three specific classes of "invisible" knowledge:

Lattice Geometry Ambiguity:
- Issue: The agent initially confused "grid rows" with "physical layers" on the honeycomb lattice, producing 4-row structures when asked for 2-layer designs.
- Resolution: The agent generated a multiple-choice diagram to clarify the mapping. The rule ( $N$ -layer = $N$ grid rows) was encoded as a persistent constraint.
- Innovation: The agent independently developed a geometric verification pipeline using tacoxDNA and oxDNA. It converted 2D designs to 3D coordinates, performed PCA decomposition, and calculated aspect ratios to autonomously verify if a design was "flat" without human feedback.
Scaffold Routing Rules:
- Issue: The agent could not determine where to place half-crossovers (edges) vs. full crossovers (interior) to create a single continuous scaffold loop.
- Resolution: After receiving a human-provided template with a "single midseam" pattern, the agent generalized the rule to arbitrary dimensions (e.g., 2-by-8, 2-by-20) without further instruction.
Cavity Design & Scaling:
- Issue: Introducing a cavity disrupted the standard routing pattern (requiring interrupted midseams and specific half-crossover placements at cavity edges).
- Resolution: The agent learned a 4-step scaling process (remove staples $\rightarrow$ extend helices $\rightarrow$ shift midseam $\rightarrow$ expand cavity) and encoded logic to prevent common errors like broken crossover references or filling the cavity with scaffold.

C. Autonomous Capabilities

Once the failure modes were resolved and knowledge formalized, the agent demonstrated the ability to:

Extend designs to arbitrary lattice dimensions (e.g., 2-by-16, 2-by-20).
Design structures to specific physical specifications (e.g., "20 nm × 40 nm cavity, centered, 6-helix padding").
Perform targeted edits via natural language prompts (e.g., "move crossovers 3–5 bp away from the cavity edge").
Execute an end-to-end pipeline: Design $\rightarrow$ Auto-staple $\rightarrow$ Format Conversion $\rightarrow$ MD Simulation on a GPU cluster.

4. Results

Success Rate: The agent achieved 100% success in generating valid designs after the initial correction phase, with no repetition of previously resolved error classes.
Validation: Designs were validated through oxDNA molecular dynamics simulations, confirming that the resulting structures maintained their intended cavity shapes and structural integrity after relaxation.
Artifact Generation: The process produced a suite of distributable artifacts (Table 1 in the paper), including:
- cadnano_verifier.py: A pre-flight validation script checking for all documented failure modes.
- failure_analysis.md: A catalog of failure modes, root causes, and fixes.
- cavity_variant_sweep.py: A parametric pipeline for generating cavity variants.

5. Significance

This work establishes a new paradigm for knowledge transfer in scientific computing:

From Ad-hoc to Formalized: It converts informal, tacit domain expertise into formalized, repeatable, and distributable text-file instructions.
Agent as a Substrate: The coding agent acts not as a replacement for the designer, but as a substrate for accumulating and distributing expertise. Each interaction produces reusable tools (verifiers, scripts) that reduce friction for future users.
Unified Interface: It suggests a path toward a unified natural language interface for diverse DNA origami tools, allowing researchers to adopt new methodologies without learning individual GUIs.
Scalability: While currently demonstrated on simple 2-layer rectangular origami, the framework provides a starting point for scaling to complex 3D, curved, and wireframe structures by systematically encoding the necessary domain rules.

In summary, the paper proves that coding agents can bridge the gap between human expertise and software tools, transforming DNA origami design from a manual, error-prone process into an automated, self-correcting, and knowledge-accreting workflow.