Project Info

DryRun

Inspiration

Protein design is powerful, but the workflow is expensive, fragmented, and hard to reason about. Researchers generate dozens of variants, run separate tools for fitness, folding, synthesis, and cost, and then still have to decide which designs are actually worth ordering. Each physical test costs real money and weeks of time, and most designs fail. We wanted a system that doesn't just rank variants in isolation, but coordinates specialist agents that each evaluate a different part of the design problem, then recommends the most cost-effective set of variants to test, before a single dollar is spent on synthesis.

What it does

DryRun is a multi-agent AI platform for protein design. You provide a protein sequence, a design goal, and a budget. DryRun runs the sequence through a coordinated pipeline of specialist agents, each owning one decision: Design Generator creates candidate protein variants. Sequence Fitness scores biological plausibility. Fold Risk predicts structural stability and fragile regions. Synthesis Cost estimates manufacturing cost. Portfolio Optimizer selects the best set under budget. Design Council reviews the selected portfolio through stability, function, diversity, synthesis, and budget lenses. Reporting Agent produces a clear final recommendation. In the background, toolbox agents run additional protein and DNA checks: codon optimization, DNA QC, hydropathy, restriction-site scanning, solubility, liability scanning, and thermostability estimation. The result is a report that helps labs avoid wasting money on low-value variants and focus their budget on designs more likely to succeed. The core idea: specialist agents that each own a real decision The strongest part of DryRun is its multi-agent architecture, where each agent owns one specific part of the design problem and contributes real evidence to a shared decision, rather than one model trying to do everything at once. Protein design is genuinely many problems at once: is this variant biologically plausible, will it fold, where is it fragile, what will it cost to manufacture, is it diverse enough to hedge risk, does it have synthesis or solubility liabilities. DryRun gives each of these its own specialist agent. The Design Generator proposes variants, Sequence Fitness scores plausibility, Fold Risk predicts structure and fragile regions, Synthesis Cost prices each construct, and the Portfolio Optimizer selects under budget, while background toolbox agents run codon optimization, DNA QC, hydropathy, solubility, liability, and thermostability checks. Each agent enriches the same shared candidate objects, so dozens of independent signals converge into one coherent recommendation instead of a pile of disconnected outputs. The agents coordinate over the Chat Protocol through Agentverse, every agent is independently discoverable and usable on its own, and the orchestrator routes work between them and recovers gracefully if any single agent fails. This is real agent-to-agent orchestration, not a single script wearing many hats. Sitting at the end of that pipeline, the Portfolio Optimizer turns all of that collected evidence into the actual decision. It is deliberately not a ranker: picking the top variants concentrates risk, because near-identical high-scoring designs tend to share the same hidden flaws and fail together. Instead, DryRun treats selection like building an investment portfolio, choosing a diversified set under budget so failures are decorrelated, maximizing the expected number of successful experiments per dollar rather than the score of any single design.

How we built it

The backend is Python with a distributed agent architecture built on uAgents. Each specialist agent has its own identity, task, capability, seed, and address, so agents can run locally in one Bureau or separately through Agentverse mailbox mode. The orchestrator receives the user request, calls each specialist over the Chat Protocol, tracks request IDs, collects results, and falls back to an in-process pipeline if any marketplace agent fails. This keeps the system reliable while demonstrating real agent-to-agent coordination. The pipeline is built around a shared candidate model. Each agent enriches the same candidate objects with new evidence: mutations, viability scores, fold confidence, fragile regions, synthesis risk, cost, success probability, and final selection status. This is what lets many agents contribute to one coherent decision instead of producing disconnected outputs. The frontend is Next.js, React, TypeScript, Tailwind CSS, and 3D molecular visualization, designed to feel like a real product: sequence intake, a live run view, candidate detail pages, a molecule studio, and final report surfaces.

Challenges we ran into

The biggest challenge was coordinating many agents without making the system fragile. If one specialist timed out, an entire run could fail, so we built resilient fallbacks and made background toolbox calls non-blocking. Another was turning complex protein-design signals into something understandable. Fold confidence, synthesis risk, GC content, fragile regions, and expected success only matter if the user can see how they shape the final recommendation. We also had to balance realism and speed. Structure prediction is slow, so DryRun supports configurable fold backends and concurrent folding while keeping the demo responsive. On the frontend, the challenge was clarity over volume. Protein design carries a lot of data, so we focused on the decision funnel: how many variants were generated, filtered, folded, priced, selected, and refined.

Accomplishments we're proud of

We built a working multi-agent system that connects generation, scoring, folding, synthesis cost, optimization, review, and reporting into one workflow focused on reducing cost and improving success rate, rather than just generating variants. We are especially proud of the Portfolio Optimizer, which chooses a diversified set under budget instead of the top-ranked variants, accounting for the fact that similar designs can fail for the same reason. We are also proud that every agent has one clear responsibility, which is what keeps a system of this many agents reasonable to understand and reliable to run.

What we learned

We learned that agent systems are most useful when each agent has a clear job. The project became far easier to reason about once every agent did exactly one thing: generate, score, fold, price, optimize, review, or report. We learned that cost is the real bottleneck in scientific AI. A model can suggest hundreds of variants, but labs need to know which experiments are worth paying for, so optimization under budget became the center of the product. And we learned that a good AI interface for a technical domain is not just a chat box. Users need traces, scores, visualizations, comparisons, and clear explanations of why the system reached its recommendation.

What's next

Make every backend model fully production-grade and reduce real structure-prediction latency. Add richer wet-lab constraints, like vendor-specific synthesis rules. Expand the agent marketplace so researchers can plug in their own specialists, such as antibody developability, enzyme activity, toxicity screening, or assay planning. Validate the predicted cost-and-success improvements against real experimental outcomes. Long term, DryRun could become an AI research operating system for protein engineering: a place where specialized agents collaborate to help labs reduce cost, improve success rate, and choose better experiments.

DryRun — decide which protein designs are worth synthesizing, before you pay to build them

ASI:One Agent Challenge — From Intent to Action

The problem, the user, and the outcome

Problem. Wet-lab synthesis is expensive and slow. Teams routinely order DNA for protein variants that were never going to work, or pile their whole budget into near-duplicate designs that all fail for the same hidden reason. The expensive part — structure prediction — gets re-run by every lab independently.
Target user. Protein engineers and synthetic-biology teams deciding which designs to actually order under a fixed budget.
Outcome the agent produces. From a plain-English goal ("improve heat tolerance of this enzyme, budget $1,500, 24 variants"), DryRun returns an executable order list: the specific, diversified set of designs to synthesize, the dollar spend, the expected number of distinct successful experiments, and how much better that is than a naive top-ranked buy — produced entirely through agent-to-agent orchestration over the Chat Protocol.

How it works

A natural-language request reaches the Orchestrator (the ASI:One entry point). It parses intent, then runs a pipeline by messaging six specialist agents over the Agent Chat Protocol, and convenes a Design Council swarm (five advisor agents + a moderator) that deliberates over the optimized portfolio and refines it:

intent → Design Generator → Sequence Fitness → Fold Risk → Synthesis Cost
       → Portfolio Optimizer → Design Council (deliberation) → Reporting

The intelligence core is the optimizer: it maximizes expected distinct successes per dollar under the budget, penalizing correlated designs so you buy a decorrelated spread of bets rather than near-duplicates.

Requirement checklist

Mandatory requirement	How DryRun meets it
Register ≥1 agent on Agentverse	All 13 agents connect via mailbox — see `backend/AGENTVERSE.md`
Implement the Agent Chat Protocol	Every agent uses `chat_protocol_spec` and publishes its manifest (`backend/agents/protocol.py`)
Discoverable + usable through ASI:One	Orchestrator publishes a descriptive Chat Protocol manifest; greets on session start and runs the full workflow from a chat message
Meaningful tool execution / orchestration	Orchestrator runs a 7-stage pipeline across specialists + a 6-agent deliberation swarm
Complete the workflow with no custom frontend	The whole decision report is produced and returned inside the ASI:One chat (the Next.js app is optional)
Public GitHub repo with run/test instructions	This repo; see Run & test below

Bonus covered: multi-agent collaboration (the Council); Payment Protocol monetization on the Fold Risk agent (see backend/README.md); reliability — every remote/agent/payment call falls back so a report is always produced; deterministic, key-free operation so it keeps running after the event.

Run & test

cd backend
python -m venv ../.venv && source ../.venv/bin/activate   # Python 3.12
pip install -r requirements.txt

# 1) Local one-process demo (all agents in one Bureau + REST gateway)
python run_all.py
curl -s -X POST http://127.0.0.1:8000/run -H 'Content-Type: application/json' \
  -d '{"goal":"improve heat tolerance, budget $1500, 24 variants","poolSize":24,"budgetUsd":1500}'

# 2) Quick check
python tests/smoke.py

To put the agents on Agentverse / ASI:One, follow backend/AGENTVERSE.md (set USE_MAILBOX=true, run python run_mailbox.py, connect each mailbox). The optional web UI lives in frontend/ (npm install && npm run dev).

Everything runs deterministically with zero API keys. An optional ASI_ONE_API_KEY enables LLM intent parsing; optional fold backends and the testnet payment fee are off by default.

Submission links

ASI:One shared chat session: add URL
Agentverse agent profile(s): add URL(s)
Demo video: add URL
GitHub repository: this repo

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

CSSIn code
Hugging FaceIn code
Next.jsIn code
OpenAIIn code
PythonIn code
PyTorchIn code
ReactIn code
Tailwind CSSIn code
TypeScriptIn code
FastAPIClaimed

9 of 10 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

Claude CodeConfig
CodexConfig
CursorCommits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

416 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.