{"slug": "an-autonomous-research-system-that-measures-how-often-it-fools-itself", "title": "An autonomous research system that measures how often it fools itself", "summary": "A solo developer built Prometheus, an autonomous research system that runs 24/7 on a single Linux workstation with one RTX 5090 GPU, generating its own questions and running over 130,000 experiments. The system is designed to distrust itself, spending a large fraction of its compute attacking its own conclusions, and publishes metrics showing it can predict claim transferability only 53% of the time and that only 2% of its claims touched real-world data.", "body_md": "**An autonomous research system that runs 24/7 on one workstation — and is built to distrust itself.**\n\nNo relation to— this project shares only the name.[Prometheus monitoring]\n\nPrometheus turns a single Linux box with one GPU into a self-directing research fleet: it generates its own questions, dispatches LLM workers to run real experiments with preserved code, extracts claims with scoped confidence, and then spends a large fraction of its compute **attacking its own conclusions** — adversarial replication, cross-domain disconfirmation, novelty verification against the actual literature indexes, and calibration audits that measure how often the system's own confidence is wrong.\n\nIt is not a chatbot, not a demo loop, and not turnkey. It is a working reference deployment: ~90 scheduled jobs, ~100 orchestration scripts, two SQLite WAL databases, three fail-open runtime plugins, and a local vLLM worker fleet on a single RTX 5090 — running continuously — over 130,000 experiments across 107,000+ dispatched tasks as of July 2026. Built solo, from scratch, in about a month, on one consumer gaming PC — as a first project.\n\nThe field's autonomous-research generators have outrun their validators; the\nopen problem is trust. So before the architecture, here is what this system\nmeasured about **its own** trustworthiness — the numbers most projects don't\npublish (snapshot: July 2026, reference deployment; the live values move on\nits dashboard):\n\n| It asked itself | Measured | Response |\n|---|---|---|\n| Can I predict which of my claims transfer to new domains? | 53% — barely above chance |\ntransfer confidence hair-cut across the board |\n| How much of my discovery shelf ever touched real-world data? | 2% — 60/62 claims ran only self-generated simulation code |\nbuilt the toy-vs-world lane to re-test against external datasets |\n| Do my simulation-validated claims survive real data? | ~71% of verified re-tests hold (15/21) |\nthe 6 refusals are catalogued as first-class results, not buried |\n| Which claim shapes do I over-trust? | MONOTONIC mechanisms, 67.6% over-trusted |\nreweighted at the calibration layer |\n\nEvery number above was produced by a scheduled job in this repo, against the system's own knowledge base, and survives on the live dashboard. The honest readings are the feature: a research system that can't tell you where it fools itself can't be trusted where it doesn't.\n\n**Receipts:** [ FINDINGS.md](/slow4cyl/prometheus/blob/main/FINDINGS.md) is a labeled snapshot of actual\noutput — the six\n\n**reality's refusals**(simulation said yes, real data said no), the verified world-holds, and the discovery shelf's top entries with their honest caveats attached. The system's self-rendered pages are served via GitHub Pages exactly as its hourly cron generated them:\n\n[knowledge topology](https://slow4cyl.github.io/prometheus/prometheus-topology.html)·\n\n[topology 3-D](https://slow4cyl.github.io/prometheus/prometheus-topology-3d.html)·\n\n[discoveries board](https://slow4cyl.github.io/prometheus/prometheus-discoveries.html)·\n\n[architecture diagram](https://slow4cyl.github.io/prometheus/prometheus-architecture-diagram.html)\n\nPrometheus is a research layer, not a standalone agent runtime. It **requires\nhermes-agent** — the open-source\nagent substrate that provides the gateway, kanban dispatcher, worker spawning,\ncron ticker, and plugin system this repo builds on. Install it first\n(see\n\n`SETUP.md`\n\n), then lay Prometheus on top.\n\n```\n curiosities ──► scoring ──► task queue (priority lanes) ──► kanban dispatcher\n      ▲                                                            │\n      │                                              ┌─────────────┴─────────────┐\n      │                                              ▼                           ▼\n      │                                    local A1 workers            API-lane workers\n      │                                  (vLLM on RTX 5090,          (burst / frontier\n      │                                   free, 6×96K ctx)             capability)\n      │                                              └─────────────┬─────────────┘\n      │                                                            ▼\n      │                                            experiments (code preserved,\n      │                                             results → worker_results)\n      │                                                            ▼\n      │                                              claims (scoped confidence,\n      │                                               claim_hash identity)\n      │                                                            ▼\n      │            ┌───────────────────────────────────────────────┴───────┐\n      │            ▼                   ▼                   ▼               ▼\n      │      adversarial         cross-domain         novelty vs      independence\n      │      attack lane         disconfirmation      literature      & circularity\n      │      (replication,       gate                 indexes         gates\n      │       contradiction)                                              │\n      │            └───────────────────┬───────────────────┬──────────────┘\n      │                                ▼                   ▼\n      │                      calibration loop        discovery spotlight\n      │                      (meta-prober,           (the terminus: what\n      │                       mechanism trust)        actually survived)\n      └────────────────────────────────┘\n        contradictions and calibration misses become new curiosities\n```\n\nEvery stage is a real, inspectable script in `scripts/`\n\n, wired into the cron\nticker by `cron/jobs.json`\n\n. Nothing is a black box.\n\n**It measures its own epistemic failure modes.** The meta-prober tests whether\nthe system can predict which of its own claims transfer to new domains (the\nreference deployment measured itself at 53% — barely better than chance — and\nresponded by hair-cutting transfer confidence). Mechanism-level calibration\nfound MONOTONIC-type claims were over-trusted at 67.6% and reweighted them.\nContradicted claims are not deleted; they are routed to an attack lane and\nfought over.\n\n**It re-tests its simulations against the world.** Every other gate in the\nsystem tests coherence — whether the system's runs agree with each other. The\ntoy-vs-world lane (`world_grounding.py`\n\n) is the only one that tests\n*correspondence*: it takes claims validated in self-generated or simulated\nsettings and re-runs them against real external datasets, with the loader\ncode preserved and mechanically classified so a worker can't claim\n\"tested against real data\" while running another simulation. In the\nreference deployment, only **~71% of verified re-tests hold** (15/21) —\nroughly three in ten simulation-validated findings are refused by reality.\nThose refusals aren't buried; they're first-class results the lane records\nand the dashboard displays. Most autonomous-research systems never ask this\nquestion; the honest answer is the strongest argument for asking it.\n\n**Confidence is scoped, capped, and adversarially earned.** Claims carry a\n`claim_scopes`\n\nledger. Attack cards target the *mapped scope*, not a\nstrawman. A confirmation from a correlated source is worth less than one from\nan independent lane (`independence_gate.py`\n\n), a claim that merely restates its\nown evidence gets caught (`circularity_critic.py`\n\n), and a \"novel\" finding must\nsurvive a check against actual literature indexes — title/abstract/venue in\nfront of the model — because an LLM's recall of the literature is not the\nliterature (`novelty_audit.py`\n\n, `scholar_search.py`\n\n).\n\n**The prose must match the code.** `method_code_alignment_critic.py`\n\nchecks\nthat what a worker *says* it did matches the preserved experiment code —\nclosing the gap most autonomous-research systems leave open (numbers get\ndrift-checked; methods sections usually don't).\n\n**Infrastructure is self-healing and update-proof.** The agent substrate\n(hermes-agent) runs *stock* — every behavioral customization lives in three\nsentinel-guarded plugins that detect upstream drift, log `PATCH_FAILED`\n\n, and\nfail **open** to stock behavior rather than breaking silently. All generic\nfixes are submitted upstream (14 PRs; carried as clean cherry-picks until\nmerged). Watchdogs watch the dashboards; a reconciliation monitor\ncross-checks the two databases against each other; a self-repair scanner\nfiles its own maintenance tasks.\n\n| Layer | What it is | Where it lives |\n|---|---|---|\nHermes (substrate) |\nGateway, kanban dispatcher, worker spawning, cron ticker, profiles | upstream\n`fork-patches/` |\n\n**Prometheus**(research app)`scripts/`\n\n, `cron/`\n\n, `plugins/`\n\n, `dashboard/`\n\nTwo SQLite databases (WAL mode, ~20 concurrent writers):\n\n**kanban.db**— dispatch: tasks, claims, heartbeats, task_events audit trail** prometheus.db**— knowledge: experiments, worker_results, knowledge_claims, claim_evidence, claim_scopes, discovery_candidates, calibration ledgers (schema in`schema/prometheus.schema.sql`\n\n— structure only, no data)\n\nThe reference deployment runs everything on **one machine**: a consumer\nworkstation with a single RTX 5090 (32 GB). The local worker is a 30B-class\nMoE served by vLLM in FP4 (~1,400 tok/s, 6 concurrent 96K-token contexts) — so the\nbulk of fleet compute is **free and local**; metered API models are reserved\nfor burst lanes. None of this is required: any OpenAI-compatible endpoint\nworks as the worker lane (see `SETUP.md`\n\n).\n\n```\nscripts/            ~100 orchestration scripts — the system itself\n                    (task_refiller, lanes, gates, critics, calibration,\n                     watchdogs, janitors, backups; gpu_sklearn/ GPU shim)\ncron/jobs.json      ~90 job definitions: schedules + prompts + script wiring\nplugins/            prometheus-guard        (worker guardrails + completion gate)\n                    prometheus-prompt-policy (memory-policy prompt rebinds)\n                    prometheus-runtime-tuning (scheduler grace, redaction policy)\n                    — all sentinel-guarded, fail-open\nconfig/             config.example.yaml + worker profile examples\nsystemd/            service units (gateway, dashboard, local model, router)\nschema/             prometheus.db schema (empty-database bootstrap)\nskills/             kanban-worker + prometheus-* skills workers load per task\ndashboard/          single-file live dashboard (fleet, lanes, alerts)\ntests/              invariant tests (HERMES_HOME-isolated): domain policy,\n                    maturity, confidence arithmetic, world-basis classifier,\n                    schema bootstrap — `HERMES_HOME=$(mktemp -d) pytest tests/`\nfork-patches/       upstream PRs carried until merged (see its README)\ndocs/               architecture-map.md — the full system reference\nREFACTORING.md      tracked structural debt (shrinking is the metric)\n                    defork-plan.md — how the substrate was made update-proof\nSETUP.md            fresh-machine bootstrap guide\n```\n\n`docs/architecture-map.md`\n\nis the deep reference: every lane, gate, dial, and\ngotcha, written to be sufficient to operate the system without the author.\n\n**Single-box, single-tenant.** No multi-node story; concurrency limits are tuned to one machine's SQLite and one GPU.**Not turnkey.**`SETUP.md`\n\nis a real bootstrap path, but constants (lane budgets, confidence caps, GPU memory dials) encode months of tuning to this hardware and workload. Expect to re-tune.**The substrate moves.** hermes-agent evolves quickly; the plugin sentinels fail open by design, and`fork-patches/upstream-prs/README.md`\n\ntracks what still needs to ride along.**Research output quality is bounded by the models you point it at.** The system's contribution is the*epistemic machinery*— generation, attack, calibration, and honest accounting — not any single model's intelligence.\n\n**MIT** (see `LICENSE`\n\n). Use it, fork it, build on it — for anything. The one\nask is baked into the license: keep the copyright/permission notice, i.e.\n**credit this project when you use it**. If Prometheus ends up in something\nyou publish or ship, an acknowledgment or a link back here is appreciated.\n\nPrometheus builds on [hermes-agent](https://github.com/NousResearch/hermes-agent)\n(MIT, Nous Research) — the substrate deserves its own credit.", "url": "https://wpnews.pro/news/an-autonomous-research-system-that-measures-how-often-it-fools-itself", "canonical_source": "https://github.com/slow4cyl/prometheus/", "published_at": "2026-07-10 14:53:54+00:00", "updated_at": "2026-07-10 15:05:22.981573+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-research", "ai-safety", "ai-agents", "ai-tools"], "entities": ["Prometheus", "vLLM", "RTX 5090", "GitHub", "SQLite", "hermes-agent"], "alternates": {"html": "https://wpnews.pro/news/an-autonomous-research-system-that-measures-how-often-it-fools-itself", "markdown": "https://wpnews.pro/news/an-autonomous-research-system-that-measures-how-often-it-fools-itself.md", "text": "https://wpnews.pro/news/an-autonomous-research-system-that-measures-how-often-it-fools-itself.txt", "jsonld": "https://wpnews.pro/news/an-autonomous-research-system-that-measures-how-often-it-fools-itself.jsonld"}}