Veyra

VEYRA is an interpretable CRISPR/Cas9 platform combining deterministic genomic algorithms with agentic AI, grounding every result in traceable tool evidence to show not just what, but why.

Comment

Inspiration

Genomic analysis is incredibly powerful, but turning raw biological data into useful, explainable decisions still requires stitching together many specialized tools, algorithms, databases, and analysis pipelines.

We wanted to build something that could sit above those tools as an intelligent reasoning layer.

That became VEYRA — Genomic Intelligence: a system where an AI can reason about genomic questions while delegating actual computation to deterministic bioinformatics tools, rather than simply guessing from language-model knowledge.

Our goal was to make genomic analysis feel less like operating a collection of disconnected command-line tools and more like interacting with an intelligent scientific system.

What it does

VEYRA combines an AI orchestration layer with deterministic genomic analysis tools.

It can:

  • Analyze DNA sequences and calculate GC content and sequence characteristics.
  • Predict secondary structure using ViennaRNA.
  • Identify candidate SpCas9 CRISPR cutting sites.
  • Analyze PAM sequences, strand orientation, GC content, and computational on-target scores.
  • Perform genome-scale scans instead of artificially truncating biological inputs.
  • Execute computationally expensive analysis in the background while preserving the original execution context.
  • Return deterministic tool evidence alongside AI-generated explanations.
  • Track tool calls, execution states, timing, errors, and provenance.
  • Allow the AI to call specialized tools instead of fabricating biological results.

A key design principle is that the AI is the reasoning/orchestration layer, while deterministic tools remain the source of computational evidence.

How we built it

VEYRA is built as a layered architecture:

Frontend → MIDEND → AI model → deterministic tools → genomic evidence

The MIDEND acts as the orchestration layer between the user and the computational backend.

We built an OpenAI-compatible provider interface so VEYRA could work with different model providers without rebuilding the orchestration system.

For our final deployment, VEYRA runs on a Google Cloud VM and uses:

  • Gemini 2.5 Flash-Lite through Vertex AI
  • Google Application Default Credentials
  • A custom OpenAI-compatible AI adapter
  • FastAPI/Uvicorn services
  • Deterministic genomic analysis tools
  • ViennaRNA for secondary-structure calculations
  • A Next.js frontend deployed through Vercel

We also built execution tracking around every AI/tool interaction so that a result can be traced back to the computation that produced it.

Challenges we ran into

The hardest part wasn't getting an AI to answer a question — it was making the entire system reliable.

We encountered:

  • Long-running whole-genome scans exceeding interactive timeouts.
  • Background execution and SSE lifecycle issues.
  • Retry logic accidentally interacting with detached background jobs.
  • Tool execution continuing after the frontend believed an execution had timed out.
  • AI provider failures caused by incompatible function-calling support.
  • Provider authentication and Google Cloud ADC integration.
  • Running long-lived services independently of SSH sessions.
  • Token expiration for Google Cloud authentication.
  • Connecting a cloud-hosted backend to a Vercel frontend under severe time constraints.

We eventually implemented background continuation, execution-state tracking, deterministic evidence, and automatic Vertex credential refresh so long-running analyses could continue without destroying the conversation state.

Accomplishments that we're proud of

The biggest accomplishment is that VEYRA became an actual end-to-end working system rather than just a prototype UI.

We successfully demonstrated:

Gemini → native VEYRA tool call → deterministic genomic computation → result → Gemini explanation

For example, Gemini successfully invoked our compute_gc_content tool, received the deterministic result, and correctly explained that:

ACGGGCAATATGTCTCTGTG has 50% GC content.

We also successfully integrated ViennaRNA and verified secondary-structure computation through the same execution architecture.

Our full-genome CRISPR pipeline can process an entire bacterial genome and produce computationally ranked SpCas9 candidate sites while preserving provenance and execution metadata.

Most importantly, we built the architecture so the AI does not have to pretend it performed a computation — it can actually call the computation and receive evidence.

What we learned

We learned that building scientific AI is fundamentally different from building a chatbot.

The difficult part is not only model intelligence. It is orchestration, determinism, provenance, failure recovery, and system reliability.

We learned to separate:

  • reasoning from computation,
  • AI output from deterministic evidence,
  • interactive execution from background execution,
  • provider infrastructure from our tool architecture.

We also learned that long-running scientific workloads need to be treated as asynchronous jobs rather than ordinary chat requests.

Most importantly, we learned that an AI system becomes much more trustworthy when it knows when to use a tool instead of guessing.

What's next for Veyra

VEYRA is still only the beginning.

Next we want to expand the deterministic tool layer with more genomic algorithms, larger reference-genome resources, stronger off-target analysis, improved guide scoring, and additional molecular-analysis capabilities.

We also want to build a richer evidence graph so every conclusion can be traced through:

question → reasoning → tool → parameters → computation → evidence → conclusion

Longer term, we want VEYRA to become a general genomic intelligence platform capable of coordinating many specialized computational biology systems while keeping scientific evidence, reproducibility, and human oversight at the center.

Built With

Share this project:

Updates