Gonka Labs Missions · gonkablocks guides

What is a Mission?

A Gonka Labs Mission is a long-running public-good research program powered by AI. Unlike a regular block that runs once and finishes, a mission fires on a cron schedule — every few hours — and accumulates knowledge over months or years.

Missions are curated by the Gonka Labs team. They target problems where near-zero-cost AI inference makes a qualitative difference: scanning millions of papers, databases, and records that no human team could continuously monitor.

Mission vs. Block

Property	Regular block	Mission
Lifecycle	Runs once, exits	Cron-fired ticks, runs forever
State	Fresh container each run	Persistent /state volume
Output	outputs.json	Findings, hypotheses, goal, discussion
Purpose	User-triggered task	Autonomous background research
Who runs it	Any user	Gonka Labs (admin-curated)

How a tick works

Each tick is one full research cycle. The scheduler fires the mission's Docker container on its cron schedule. Inside, a 7-phase multi-agent swarm runs to completion:

Director — reads the current goal and knowledge base, picks 3 research focus areas for this tick.
Scouts (parallel) — fetch new items from all data sources simultaneously. Each source checkpoints where it left off.
Synthesizer — reads the scout output, proposes hypotheses with evidence and confidence scores.
Critic / Skeptic — challenges each hypothesis: evidence quality? confounders? reproducibility? Rates them STRONG / SPECULATIVE / WEAK.
Curator — resolves the debate. Promotes strong findings to the public feed, updates the hypothesis registry.
Reporter — writes the public tick summary in plain language, with scientific caveats.
Director-meta — if the current goal is exhausted or a better direction has emerged, evolves the goal for future ticks.

The full discussion transcript — every agent's prompt and response — is stored and shown on the mission dashboard.

Agent roles

Role	Job
`Director`	Sets the research focus for the tick
`Scout`	Screens fetched literature, groups by theme
`Synthesizer`	Finds correlations, proposes hypotheses
`Critic / Skeptic`	Challenges claims, flags confounders
`Curator`	Decides what gets published vs. tracked
`Reporter`	Writes the public-facing summary
`Director-meta`	Evolves the mission goal over time

Cancer Research — the first mission

The Cancer Research mission is the first Gonka Labs Mission. Its goal: find off-label drug repositioning candidates — existing approved drugs that show evidence of anti-cancer activity but have never been tested in oncology trials.

Drug repositioning is one of the most promising and under-explored areas of cancer research. A drug like metformin (approved for diabetes) or mebendazole (an anti-parasitic) may have mechanism-of-action profiles that overlap with known cancer pathways. The AI scans literature for these overlaps continuously, every 4 hours.

The mission has a persistent knowledge graph that grows with each tick. The Director-meta role may evolve the research goal as evidence accumulates — for example, shifting focus from broad screening to a specific drug–pathway pair that is gaining confidence.

This is not medical advice. All candidates surfaced by this mission require experimental validation before any clinical consideration.

Data sources

The Cancer Research mission scans six public sources on every tick (no API keys required):

Source	What it provides
`PubMed`	Peer-reviewed biomedical abstracts (NCBI E-utilities)
`Europe PMC`	European open-access literature
`bioRxiv / medRxiv`	Preprints — early findings before peer review
`ClinicalTrials.gov`	Ongoing and completed clinical trials (v2 API)
`OpenTargets`	Structured gene–disease–drug evidence (GraphQL)
`OpenFDA`	FDA-approved drug labels and indications

What gets published

After each successful tick the platform reads these files from /out/:

/out/findings/<id>.json — a public finding (drug candidate, correlation, open question, …)
/out/hypotheses/<id>.json — a tracked hypothesis with confidence score
/out/goal.json — an updated mission goal (only written when Director-meta changes it)
/out/discussion.jsonl — the full agent transcript, one JSON object per line
/out/tick.json — tick summary written by the Reporter

All files are optional — missing files are silently skipped.

Persistent knowledge

The swarm keeps a SQLite knowledge graph at /state/knowledge.db that persists across all ticks via a Docker named volume. The Curator stores entities (drugs, diseases, genes, papers) and relations (drug-inhibits-pathway, paper-supports-hypothesis) so future ticks can query prior knowledge without re-reading all raw text.

Over months of operation this becomes a compact, machine-queryable distillation of everything the swarm has learned — growing richer every 4 hours.

Authoring a new mission

Missions are currently admin-curated. If you have a public-good research idea that would benefit from continuous AI scanning, reach out to Gonka Labs.

Technically a mission is a block with type: mission in manifest.yaml:

name: my-mission
version: 0.1.0
type: mission
description: "What this mission investigates."
category: research

runtime:
  build: dockerfile
  entrypoint: python -u tick.py
  outputs_dir: /out

resources:
  cpu: 2
  memory_mb: 4096
  timeout_seconds: 7200
  network: allow

mission:
  tick_cron: "0 */4 * * *"
  state_dir: /state
  per_tick_timeout_seconds: 5400
  tagline: "One-line summary for /missions"
  initial_goal: |
    Describe the research goal in 2-3 sentences.

The _lib/ swarm library

All missions share a reusable Python library at seed/missions/_lib/, automatically included in every mission's Docker build context:

_lib/
  swarm.py         # Swarm class — runs the full 7-phase tick
  roles.py         # Role class — one LLM call + transcript append
  knowledge.py     # KnowledgeStore — sqlite entity/relation graph
  outputs.py       # OutputWriter — /out/findings/, /out/hypotheses/, …
  sources/
    pubmed.py      # PubMed E-utilities
    europepmc.py   # Europe PMC REST API
    biorxiv.py     # bioRxiv / medRxiv
    clinicaltrials.py  # ClinicalTrials.gov v2 API
    opentargets.py     # Open Targets GraphQL
    openfda.py         # OpenFDA drug labels

A minimal tick.py:

from _lib import KnowledgeStore, OutputWriter, Role, Swarm
from _lib.sources.pubmed import PubMedSource

kb     = KnowledgeStore()
writer = OutputWriter()
roles  = {
    "director":    Role.from_prompt_file("director",    "prompts/director.md"),
    "scout":       Role.from_prompt_file("scout",       "prompts/scout.md"),
    "synthesizer": Role.from_prompt_file("synthesizer", "prompts/synthesizer.md"),
    "critic":      Role.from_prompt_file("critic",      "prompts/critic.md"),
    "curator":     Role.from_prompt_file("curator",     "prompts/curator.md"),
    "reporter":    Role.from_prompt_file("reporter",    "prompts/reporter.md"),
}
sources = [PubMedSource(query="your research query")]
swarm   = Swarm(roles=roles, sources=sources, kb=kb, writer=writer)
swarm.run_tick(current_goal="Your mission goal here.")

Scientific disclaimer

Findings generated by Gonka Labs Missions are produced by an AI system scanning published literature. They highlight potentially interesting research directions — not medical advice. All drug repositioning candidates require experimental validation before any clinical consideration. Confidence scores reflect the AI's assessment of evidence quality, not clinical certainty.