concordAIS is a public operator surface for scientific AI workflows. It brings public retrieval, bounded execution, provenance tracking, governed review, and operator monitoring into one continuity-driven view.
This repo is a small Python/FastAPI application. It is easiest to run with
uv.
Core Python packages used here:
fastapiuvicornhttpxjinja2pydanticopenaidaytona
Project metadata lives in pyproject.toml.
If you want the common local commands, use the helper scripts:
This public repository is intentionally explicit about what is directly shown here, what has been validated independently, and what remains intentionally undisclosed.
| Layer | Public status | Public-safe statement |
|---|---|---|
| concordAIS operator surface | shown in this repo | The app, agenthon-001 flow, APIs, and judge media are directly visible here. |
| Tavily retrieval + Daytona bounded execution | shown here, live-capable | The primary demo path is implemented here and can run live when credentials are present, with honest fixture-backed fallback when they are not. |
| SeedGraph | independently validated | SeedGraph has separately completed end-to-end import and continuity handling for 50 public publications. This repo shows the operator-facing, SeedGraph-aligned continuity surface rather than the full SeedGraph stack. |
| Antigence | independently validated | Antigence has been trained and tested as the safety and security layer in separate project artifacts. This repo exposes outcome-level review framing, not internal thresholds, weights, or private policy details. |
| Ollarma | independently validated | Ollarma has been tested with multiple local model lanes for routing, swarm support, and orchestration. This repo exposes the connected operator-facing surfaces rather than the full internal routing logic. |
| NVIDIA/OpenClaw/Nemotron | independently validated, optional | A local OpenClaw path and a live Nemotron response were validated separately and can be referenced as optional supporting proof. This is not the primary judged path. |
Public proof policy:
- We can provide outcome-level proof, independent module validation, and supporting artifacts on request.
- We do not publicly disclose thresholds, weights, prompts, internal policies, private datasets, or other trade-secret implementation details in this repo.
- Not every validated capability is reproduced end to end inside this one public repository.
Judges should read the system in four separate layers rather than as one undifferentiated AI block.
| Boundary | Primary owner in this stack | What it means here | What it does not mean |
|---|---|---|---|
| ML / inference boundary | OpenAI models, local model lanes, optional Nemotron lane | Models generate bounded outputs for retrieval synthesis, execution support, or optional second-opinion behavior. | The model layer does not own provenance, governance, release policy, or truth by itself. |
| Swarm boundary | Ollarma plus optional multi-lane support surfaces | Swarm means coordination across multiple tools or model lanes, including agreement or disagreement signals and helper routing. |
It is not the same thing as the judged baseline path, and it is not a claim that every run is fully autonomous multi-agent execution. |
| Orchestration boundary | concordAIS, Watchtower, GettingScienceDone, Daytona | Orchestration means the operator-visible sequencing of retrieval, evidence packaging, bounded execution, and review. |
It is not the same thing as training, raw model inference, or private internal routing logic. |
| Provenance and safety boundary | SeedGraph, Antigence, Concordance Monitor | Provenance continuity, self-versus-nonself review, antibody-style safety framing, and concordance or discordance cues sit outside the raw ML output. | These layers are not claimed as secret hidden magic inside one model response. |
Practical reading rule:
MLanswers or transformsswarmcoordinates or comparesorchestrationsequences and governsprovenance and safetycheck whether the workflow stayed coherent
This is the shortest public-safe comparison table for what is shown here versus what has been validated in adjacent modules.
| Surface | Boundary | Public comparison data | Public interpretation |
|---|---|---|---|
| concordAIS demo path | orchestration | 60/60 repo tests passed across test_api, test_control_plane, and test_config on 2026-04-11 |
The public demo path in this repo is implemented, exercised, and judge-ready as a bounded orchestration surface. |
| SeedGraph | provenance | 50 public publications imported end to end in separate validation; Merkle registry and evidence-chain continuity surfaces are represented here |
The demo shows the operator-facing continuity layer, not the full SeedGraph import stack. |
| Antigence | safety + ML comparison | 8 antibody systems, 39 antibodies, 7 detector backends benchmarked on 20 antibodies; 150 evaluation samples across 4 domains; NegSel mean MCC 0.605 vs IsolationForest 0.292; AE mean F1 0.800 vs IF 0.566 |
Antigence has independently measured safety and verification performance; this repo uses the outcome-level framing, not secret weights or thresholds. |
| Ollarma | swarm + ML support | 7 MCP tools exposed; benchmark suites for code, science, and swarm; determinism validated at 5/5 identical live outputs on a science task |
Ollarma has measurable local-model routing and swarm-support validation, but this repo exposes only the operator-facing helper boundary. |
| NVIDIA/OpenClaw/Nemotron | optional ML sidecar | 1 validated local OpenClaw bring-up with a live Nemotron response captured in the hackathon run-up |
NVIDIA remains a legitimate optional supporting lane, not the primary judged path. |
Proof for each row can be provided on request without publishing private thresholds, prompts, weights, or internal policies.
The system is intentionally split between:
deterministic guardrails, which should behave predictably and be auditableprobabilistic inference, where models generate useful but non-guaranteed outputs
| Category | Examples in this stack | Public-safe interpretation |
|---|---|---|
| Deterministic guardrails | bounded Daytona execution, route and readiness contracts, SeedGraph continuity checks, explicit review surfaces, fixture-backed fallback behavior, repo tests, operator-visible stage sequencing | These layers keep the workflow constrained, inspectable, and replayable enough for human supervision. |
| Probabilistic inference | retrieval synthesis, model-generated summaries, optional Nemotron second-opinion output, local-model helper routing, swarm comparison signals | These layers provide speed, creativity, and hypothesis generation, but they do not become truth merely by being fluent. |
Design rule:
concordAIS uses deterministic guardrails to contain creative probabilistic inference.
That is the practical novelty: not replacing science with model output, but wrapping model output in enough structure that a human can keep up.
| Track | Status in this repo | How it is used or would be used |
|---|---|---|
| Daytona | primary judged path | Provides the bounded execution lane for the visible end-to-end demo flow. |
| Tavily | active supporting lane | Provides the public retrieval lane that feeds the evidence packet and downstream review. |
| NVIDIA/OpenClaw/Nemotron | optional supporting lane | Provides an independently validated local second-opinion or sidecar inference path, not the primary judged baseline. |
If judges ask why this matters:
- Daytona shows controlled execution
- Tavily shows evidence retrieval
- NVIDIA shows extensible optional model-sidecar support
Together they support the claim that concordAIS is building a multi-sensory scientific analysis layer on top of traditional methods so humans can keep up with faster AI workflows.
concordAIS is designed for a scientific AI workflow that behaves less like one chatbot and more like a small swarm of cooperating systems. The product is built around one practical question:
can an operator see when an autonomous workflow is still aligned, and can they notice when the evidence chain, execution path, or reviewing agents begin to drift?
The value is not just "AI that can do science." The value is an operator surface that makes scientific AI inspectable, governable, and interruptible while it is running.
Most AI demos show a prompt and a result. concordAIS is aimed at the harder problem: making autonomous scientific workflows visible enough to trust, audit, or stop.
Its novelty comes from the combination of:
- provenance continuity with SeedGraph
- bounded execution with GettingScienceDone and Daytona
- multi-model routing and local-first helper support with Ollarma
- biologically inspired safety review with Antigence
- governed orchestration and review with Watchtower
- audio-first swarm observability through the Concordance Monitor
Taken together, those layers create a workflow where the operator can see not only the output, but also whether the workflow stayed coherent on the way there.
- Swarm: a coordinated set of tools, models, and review steps working together during one workflow rather than a single model producing one window of text.
- ML boundary: the point where model inference stops and operator-facing provenance, orchestration, and governance begin.
- Orchestration boundary: the layer that coordinates retrieval, execution, review, and operator control without claiming to be the model itself.
- AGI-ready operator surface: a human-facing control layer built for increasingly autonomous systems, where inspection and intervention matter as much as raw capability.
- Merkle continuity: a hash-linked view of evidence and derived artifacts that helps the operator detect whether lineage stayed intact across imports and downstream steps.
- Cryptographic provenance: using hashes and continuity checks to make the evidence trail tamper-evident and easier to audit.
- Artificial immune system: a biologically inspired safety pattern that treats anomalies, mismatches, and unsafe transitions as signals to inspect, escalate, or contain.
- Self versus nonself: a practical trust split between project-owned, expected, policy-approved artifacts and foreign, untrusted, or out-of-scope inputs that may need containment, review, or rejection.
- Antibodies: Antigence detection patterns that flag risky structure, anomalous transitions, unsafe content, or nonself inputs during a workflow.
- Concordance: a high-agreement state in which the visible evidence chain, execution path, and review layers remain aligned.
- Discordance: a drift state in which the operator should slow down and inspect the workflow more closely.
- Bounded execution: a constrained runtime step with explicit inputs, visible scope, and inspectable outputs.
- Governed review: a review pass that checks the result against safety, provenance, and operator rules instead of assuming the execution result is self-validating.
- TRAITS: the quality frame used across the system: Traceable, Rigorous, Accurate, Interpretable, Transparent, and Secure.
- Ollarma: the local-first helper and routing surface used for deterministic support tasks, model selection, and connected operator workflows.
This repository currently serves that product surface from the existing
watchtower package layout. The product name is concordAIS. The internal
modules remain distinct and visible:
- SeedGraph handles publication import, hashing, and provenance continuity through a Merkle-based view of the evidence trail.
- GettingScienceDone carries bounded execution on the working lane.
- Ollarma supports local-first helper routing, deterministic support work, and multi-model connected operations.
- Antigence provides the safety and security layer around AI-conducted computational science, including antibody-style pattern checks and self versus nonself distinctions.
- Watchtower supports governed review and orchestration.
- Concordance Monitor adds an audio-first signal for concordance and discordance during multi-step runs.
- Overwatch remains the canonical control plane behind the surface.
This is the highest public-safe architecture level for each module.
| Module | Public-safe architecture | Boundary role |
|---|---|---|
| concordAIS | Operator-facing web surface, API layer, judge media bundle, and project-scoped demo flow | Presents the system to the human operator and keeps the judged path legible |
| Watchtower | FastAPI app, route layer, template rendering, demo assembly, control-plane reads, and review surfaces | Owns orchestration entry, project pages, and governed review presentation |
| SeedGraph | Evidence-seed ingestion, atomization, graph linkage, Merkle registry, and continuity verification surfaces | Owns provenance continuity and traceable evidence structure |
| GettingScienceDone | Bounded execution contracts, deterministic workflow steps, notebook or lab-note framing, and runtime guardrails | Owns execution structure rather than model choice or provenance truth |
| Ollarma | Local benchmark harness, model routing surface, bounded helper tools, HTTP and MCP interfaces, and swarm-support adapters | Owns local model support, routing, and multi-lane helper coordination |
| Antigence | Antibody systems, self-versus-nonself framing, anomaly detection, offline scoring, and safety review outputs | Owns safety and security review framing around AI workflows |
| Concordance Monitor | Paired visual and audio cues derived from observable run state such as continuity, drift, contradiction, and stage progression | Owns accessibility-first operator awareness, not truth generation |
| NVIDIA/OpenClaw sidecar | Optional local sandbox and model sidecar for bounded Nemotron-backed proof-of-life runs | Optional supporting ML lane, not the primary judged baseline |
| Overwatch | Portfolio control plane, canonical truth surfaces, inventory, and cross-project governance context | Owns the higher-order control plane outside the app surface |
Public-safe architecture rule:
- it is safe to describe component roles, interface types, and validation outcomes
- it is not safe to disclose hardcoded pathways, prompts, thresholds, weights, secrets, or private internal policy details
Figure 1. concordAIS logic map
+----------------------+
| Overwatch |
| portfolio truth, |
| inventory, governance|
+----------+-----------+
|
v
+-------------+ +-------------+ +-------------------+
| Tavily | -> | SeedGraph | -> | GettingScienceDone|
| public | | evidence | | + Daytona bounded |
| retrieval | | packet + | | execution |
| lane | | Merkle-style| +---------+---------+
+------+------+ | continuity | |
| +------+------+ v
| | +------------------+
| +-----------> | Watchtower |
| | review surfaces, |
| | orchestration, |
| | project page |
| +---------+--------+
| |
| v
| +------------------+
+------------------------------> | concordAIS |
| operator-facing |
| UI + demo flow |
+----+--------+----+
| |
| v
| +------------------+
| | Concordance |
| | Monitor |
| | accessibility- |
| | first cues |
| +------------------+
|
v
+----------------------+
| Human operator |
| inspect / compare / |
| interrupt / proceed |
+----------------------+
Supporting and optional sidecars:
- Ollarma spans the swarm and local-model support boundary around routing,
helper tools, and multi-lane comparison.
- Antigence spans the safety boundary around self-versus-nonself review,
anomaly framing, and governed escalation.
- NVIDIA/OpenClaw/Nemotron is an optional supporting ML sidecar, not the
primary judged path.
Top-level directories:
watchtower/- Python application packagedemo/- demo project data and judge media bundledocs/- operator, demo, and governance documentationtests/- API and control-plane testsoutput/- local generated media and Playwright artifactsscripts/- lightweight local helper scripts
Important backend modules:
watchtower/api.py- FastAPI app and route definitions
watchtower/hackathon_demo.py- demo assembly, run packaging, execution-lane handling, concordance and NVIDIA lane shaping
watchtower/control_plane.py- portfolio/control-plane reads, project detail, blockers, opportunities, and inventory surfaces
watchtower/ai_router.py- local Ollarma routing and workflow submission helpers
watchtower/traits.py- TRAITS scoring and overview logic
watchtower/config.py- environment loading and shared paths/URLs
watchtower/templates/- HTML templates
watchtower/static/- JavaScript and static frontend assets
concordAIS is built around a few simple multi-model rules:
- no single model is treated as the whole system
- retrieval, execution, provenance, and review remain separable
- disagreement is surfaced rather than hidden
- local helper lanes remain available when possible
- review stays explicit even when the execution step succeeds
- operator visibility matters as much as raw model capability
The crux of concordAIS is the combination of:
- cryptographic-style evidence continuity
- swarm-level agreement and disagreement monitoring
- self-versus-nonself safety checks with antibody-style review
- TRAITS-oriented quality gating
- biologically inspired safety review
- bounded scientific execution
That combination is what makes the system different from a standard agent demo. It is not just helping models do scientific work. It is making autonomous scientific workflows visible enough for a human operator to trust, question, or interrupt them.
The Concordance Monitor is defensible as an accessibility and operator-support surface, not as a claim that the system can detect AGI or diagnose hidden model intent.
Why that framing is sound:
- it converts visible workflow state into redundant visual and audio cues
- it helps more humans perceive continuity, drift, and disagreement during a run, including users who benefit from paired-modality feedback
- it remains grounded in observable workflow fields such as provenance continuity, contradictions, drift, and stage progression
- it does not claim to measure consciousness, agency, or internal model truth
Current AI versus future autonomy:
- for current AI systems, the monitor is an accessibility-first human oversight aid over bounded workflow state
- for more autonomous future systems, including stronger multi-agent or AGI-like operator environments, the same human-accessibility argument becomes more important, not less
Public-safe one-liner:
The Concordance Monitor is a paired-modality accessibility layer for human oversight of AI workflows. It translates observable continuity and drift signals into visual and audio cues, without claiming to detect AGI, consciousness, or hidden model intent.
The current public demo centers on agenthon-001. It walks one operator step
from request to evidence, bounded execution, review, and optional monitoring.
The judged baseline is simple:
- Tavily retrieves public evidence.
- concordAIS renders a SeedGraph-aligned evidence packet and continuity view.
- GettingScienceDone executes the bounded step on the Daytona lane.
- Watchtower closes the loop on the review side.
- Concordance Monitor gives the operator an optional audio cue if the run starts to drift.
NVIDIA/OpenClaw was validated locally with a live Nemotron response and remains available as an optional supporting lane within concordAIS alongside the primary demo path.
The simplest public submission bundle lives under:
Direct judge-facing assets:
Supplemental concordance samples remain in:
If only one partner track can be selected, choose Daytona.
Why Daytona is the stronger single-track fit:
- the live working lane in the demo is the Daytona execution lane
- bounded sandboxed execution is the clearest differentiator in the visible run
- the operator story is stronger when retrieval, execution, and review resolve around one explicit execution surface
Tavily remains essential to the retrieval side of the workflow and stays visible in the demo, but the best single-track submission is the Daytona path.
cd <repo-root>
bash scripts/run_dev.shThen open http://127.0.0.1:8000.
cd <repo-root>
bash scripts/test.shUseful surfaces:
GET /projects/agenthon-001GET /projects/agenthon-001/demo-runGET /api/demo-projectsGET /api/demo-projects/agenthon-001POST /api/demo-projects/agenthon-001/runPOST /api/projects/agenthon-001/run
The interface stays readable in degraded mode, but connected behavior depends on upstream services:
WATCHTOWER_OVERWATCH_ROOTpoints at the canonical Overwatch export.WATCHTOWER_OLLARMA_URLpoints at the local helper service.WATCHTOWER_SEEDGRAPH_URLpoints at a running SeedGraph read surface.POST /api/orchestrateremains approval-gated and blocks governance-owned actions such ascommit,push,mirror,backup,release, andwriteback.
GET /api/overviewGET /api/projectsGET /api/projects/{project_id}GET /projects/{project_id}GET /api/resourcesGET /api/inventory/overviewGET /api/inventory/rootsGET /api/inventory/searchGET /api/operator/contractsGET /api/ollarma/statusGET /api/tasksGET /api/opportunitiesGET /api/opportunity-lanesGET /api/operator/readinessGET /api/blockersGET /api/traits/overviewGET /api/traits/projectsGET /api/seedgraph/statusPOST /api/chatPOST /api/queryPOST /api/orchestrate