Inspiration
Some records have to outlive every computer a company owns. EU clinical-trial master files must be kept for at least 25 years, and bank records, legal holds and film masters have similar rules. Hard drives and tape need replacing every 5 to 10 years, and since LTO-8 a tape drive can only read one generation back, so a 25-year archive has to be copied onto new hardware again and again. Meanwhile data centres used about 415 TWh in 2024, roughly 1.5% of the world's electricity, and most stored enterprise data is cold data that almost nobody reads.
On paper, DNA is the answer. It has been written at 215 petabytes per gram, readable DNA has been recovered from two-million-year-old sediment, and a sealed tube needs no power and never needs migrating. DNA storage companies are starting to appear. But DNA is a noisy medium: letters get swapped, inserted and deleted, and whole strands disappear. Choosing an encoding, deciding how much redundancy to pay for, and proving that a file will really come back is specialist research work. No compliance team has someone who can do it.
A good codec is necessary, but it is not a product. We wanted to answer a different question: what would it take for a pharma company to actually trust DNA with its records? Our answer is an engineer that does the whole job and leaves proof behind.
What it does
Lazarus is a team of AI agents that writes a company's records into DNA and then proves it can read them back. You upload your files and a retention policy: how many years, which sequencing technology the vendor uses, how many reads per strand you plan to pay for, a budget, a recovery target and how many vault sites you have.
A supervisor agent plans the job and hands the work to specialists. A codec engineer runs real encode, sequence and decode experiments and finds the cheapest design that meets the target. An adversary then attacks that design four ways: it destroys a vault site, switches to a different sequencer model the design was never tuned on, doubles the storage time, and cuts the reads by 40%. If any attack breaks the design, the supervisor redesigns it and the adversary reruns all four attacks on the new version. Before anything is ordered, a human approves the modeled cost.
Lazarus then writes vendor-ready order.fasta and order.csv files for each vault, plus a manifest that is itself stored in DNA. After a second approval it deletes the original files. A recovery engineer rebuilds every file from the surviving vaults alone and checks each one against the SHA-256 fingerprint taken at upload. A compliance agent writes a report that states only facts from the log, including a chain of custody of every agent action. The verdict is PASS only when every hash matches. Otherwise it says PARTIAL, FAIL or INCOMPLETE and names the reason.
The LLM never writes a DNA letter and never invents a number. Every recovery rate, cost and verdict comes from a tool that runs the real codec.
How we built it
The DNA core is deterministic Python. Each file is compressed with zstd and encrypted with AES-256-GCM under its own key. The key stays in the customer's key store and the DNA only carries a key id, so stolen DNA is unreadable, and a single flipped bit fails the GCM tag. All encrypted files are joined into one stream and cut into equal pools of up to 12 KB. Each pool is Fountain coded into 110-letter strands: a 16-letter seed, then 94 letters of XOR-mixed data with a CRC-16. Any set of good strands slightly larger than the number of chunks rebuilds the pool, so lost strands and lost sites are survivable. Strand i goes to vault i mod N, and every vault gets a full copy of the manifest.
The manifest was the most interesting design problem. The decoder needs settings like strand length, redundancy, chunk counts and file offsets. If those live only in our software, they are gone in 50 years. So the manifest is a fixed 4,096-byte block written into DNA with one published setting. A future reader needs only a one-page bootstrap spec to read it, and the manifest explains how to read everything else.
Recovery simulates sequencing with a channel model calibrated on real Nanopore reads. Every pool is decoded with both a classic majority vote and a 0.8M-parameter CNN that corrects the vote. Strands that fail their checksum are dropped, the Fountain code is solved, a CRC-32 checks each pool, and each file is decrypted and compared by SHA-256. The output is exact bytes or nothing.
The agent layer uses LangChain deepagents. The supervisor plans with write_todos, which streams live to the UI, and delegates to five subagents with their own context and tools: codec-researcher, codec-engineer, adversary, recovery-engineer and compliance. Design notes go into the agent's virtual filesystem. Ordering DNA and deleting originals both sit behind interrupt_on, and LangGraph's checkpointer resumes the run exactly where the human left it. The supervisor runs on Gemini 2.5 Flash or Claude. Autopilot runs the same tools on a fixed recipe with no LLM, for offline demos and as a control.
The backend is FastAPI with server-sent events. The workspace is React, TypeScript and Vite, with Recharts for the experiment chart and stress table, a 3D viewer that renders the real strands from the order files using oxView, and a storage scale explorer. Archives can be stored locally or in Supabase. For long-term recovery, every archive ships a Recovery Package: a ZIP with the manifest, codec settings, synthesis files and an offline decoder, lazarus-decode, that takes laboratory FASTA or FASTQ reads and returns verified files on a machine that has never seen the archive.
The Fountain encoder, both channel simulators and the pre-trained CNN decoder come from an existing open-source DNA codec project. They are bundled with permission and used unchanged. Everything else, including the agent team, the red-team loop, encryption and key management, vault placement, the DNA manifest, read clustering, the recovery drill, the Recovery Package and the app, we built at HackPrinceton.
Challenges we ran into
Small Fountain codes are fragile. Our first version split each file into its own pools, which left tiny leftover pools, and those recovered far less reliably than large ones. Vault-loss tests kept failing. We switched to packing every file into one stream with equal-sized pools, and to attacking the whole archive instead of a single pool, since a trial only counts if every pool comes back.
The agent kept trying to order designs it had not tested. After a failed attack it would raise redundancy, then propose the new design using results measured on the old one. Prompts helped but were not enough. We made approval a rule in code: an order can only be approved if that exact design, with the same redundancy, coverage, decoder and rules, passed all four attacks itself. Orders that fail the check go back to the agent with the missing tests named, at most three times, so it cannot loop forever.
Picking the best design out of many simulated trials picks the lucky one. We now select designs on training seeds only, and the chosen design gets one final test on held-out seeds that are never re-rolled. A failed final test blocks the order. One of our tiny-image runs failed that test, and we kept it on record instead of rerunning until it passed.
Real sequencers do not hand you reads grouped by strand, but the simulator did, so our first decoder only worked on simulated output. We wrote a clustering step that groups a flat, shuffled pile of reads by similarity alone, using k-mer lookup and edit distance. Whitening helps here: different strands look random to each other, while reads of the same strand differ by only a few percent. Lab reads also arrive in both orientations, so the decoder checks each consensus strand's checksum forwards and in reverse complement.
Accomplishments that we're proud of
A file goes in, the originals are deleted, and the same bytes come back from DNA alone. The Northstar Bio sample archive rebuilds 3 of 3 records byte for byte from three vaults after 50 simulated years. In a live Gemini run on a 25,144-byte lab notebook image, the agents found that both the standard and the learned design failed vault loss at redundancy 0.8 and passed at 1.2. The final held-out tests passed, and the image came back from 410,190 DNA letters with a matching SHA-256.
The red-team loop does real work. In our runs, redundancy 0.6 survived losing a vault in 0 of 4 trials, 1.2 in 2 of 4 and 1.5 in 4 of 4.
The CNN decoder reconstructs 82.3% of strands exactly at 6 reads, against 67.2% for the classic vote, on held-out real Nanopore data. A single raw read is exactly right only 1.1% of the time.
There are 140 automated tests. They cover the full deep-agent graph with both human approvals driven by a scripted model, decoding the manifest from the bootstrap spec alone, recovery from 2 of 3 vaults, and corrupted strands never producing wrong bytes.
Mostly, we are proud of what we did not claim. Costs are labeled as modeled, the DNA is simulated and says so, and a PASS is one trial, not a guarantee.
What we learned
An agent is only as trustworthy as the rules around it. Our best prompts still let the model reuse old evidence. Guardrails in code, such as exact-design approval and tools that refuse to touch frozen inputs, did what prompts could not. The pattern that worked was letting the LLM decide what to test and letting deterministic code decide what is true.
We also learned how much of DNA storage is not about DNA. Encryption, key custody, the manifest, vault placement and the recovery drill turned out to be most of the product. And we learned to keep our failed runs. They are the evidence that the passing ones mean something.
What's next
The first step is a wet lab: synthesize a real archive, store it, sequence it, and check that the Recovery Package and lazarus-decode work on reads from physical DNA. After that come real vendor APIs for synthesis orders, a production key management service with user accounts, archives larger than 200 KB, and many more trials per design. The business model is a per-archive design and certification fee plus a subscription for scheduled recovery drills, as a vendor-neutral design-and-verify layer that works with any DNA storage provider.
Built With
- claudecode
- deepagents
- fastapi
- gemini
- javascript
- langchain
- langgraph
- playwright
- python
- pytorch
- react
- supabase
- typescript
- uvicorn
- vite