From 99c94f71f03717672089d57ad352e1f9775ee743 Mon Sep 17 00:00:00 2001 From: Shay Date: Tue, 2 Jun 2026 09:20:54 -0700 Subject: [PATCH 1/3] add amr decision substrate demo --- demos/amr_decision_substrate/.gitignore | 1 + demos/amr_decision_substrate/README.md | 42 +++ demos/amr_decision_substrate/__init__.py | 1 + demos/amr_decision_substrate/run_demo.py | 319 +++++++++++++++++++ demos/amr_decision_substrate/scenarios.jsonl | 3 + docs/research/brain_corp_dossier.md | 157 +++++++++ docs/research/cto_pressure_test.md | 169 ++++++++++ 7 files changed, 692 insertions(+) create mode 100644 demos/amr_decision_substrate/.gitignore create mode 100644 demos/amr_decision_substrate/README.md create mode 100644 demos/amr_decision_substrate/__init__.py create mode 100644 demos/amr_decision_substrate/run_demo.py create mode 100644 demos/amr_decision_substrate/scenarios.jsonl create mode 100644 docs/research/brain_corp_dossier.md create mode 100644 docs/research/cto_pressure_test.md diff --git a/demos/amr_decision_substrate/.gitignore b/demos/amr_decision_substrate/.gitignore new file mode 100644 index 00000000..89f9ac04 --- /dev/null +++ b/demos/amr_decision_substrate/.gitignore @@ -0,0 +1 @@ +out/ diff --git a/demos/amr_decision_substrate/README.md b/demos/amr_decision_substrate/README.md new file mode 100644 index 00000000..c71a241d --- /dev/null +++ b/demos/amr_decision_substrate/README.md @@ -0,0 +1,42 @@ +# AMR Decision Substrate Demo + +This demo is robotics-adjacent, not a robotics stack. + +It uses simulated abstract situation records to show CORE as a decision and +accountability substrate around a bounded AMR-style proceed / stop / refuse +choice. The inputs are not camera, LiDAR, odometry, SLAM, localization, motor, +or fleet-control data. + +What is real CORE here: + +- `ChatRuntime` +- `CognitiveTurnPipeline.run(...)` +- recognition-side typed refusal propagation +- `CognitiveTurnResult.trace_hash` +- CORE Trace Protocol canonical JSONL events +- `verify_chain(...)` replay validation + +What is simulated: + +- the AMR situation record +- the tiny policy reducer that maps already-abstracted facts to + `PROCEED`, `STOP`, or `REFUSE` + +The demo refuses under-determined input instead of guessing. It also runs the +same scenarios twice through fresh runtime instances and asserts byte-identical +trace JSONL. + +Run from the repository root: + +```bash +UV_PROJECT_ENVIRONMENT=/tmp/core-amr-decision-uv uv run python demos/amr_decision_substrate/run_demo.py +``` + +Artifacts are written to: + +```text +demos/amr_decision_substrate/out/ +``` + +The important artifact is `summary.json`; `trace_a.jsonl` and `trace_b.jsonl` +are the two replay runs that must match byte-for-byte. diff --git a/demos/amr_decision_substrate/__init__.py b/demos/amr_decision_substrate/__init__.py new file mode 100644 index 00000000..0e3dfbd8 --- /dev/null +++ b/demos/amr_decision_substrate/__init__.py @@ -0,0 +1 @@ +"""AMR decision/accountability substrate demo.""" diff --git a/demos/amr_decision_substrate/run_demo.py b/demos/amr_decision_substrate/run_demo.py new file mode 100644 index 00000000..d1b7e4f0 --- /dev/null +++ b/demos/amr_decision_substrate/run_demo.py @@ -0,0 +1,319 @@ +from __future__ import annotations + +import hashlib +import json +import sys +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Any, Literal + +REPO_ROOT = Path(__file__).resolve().parents[2] +if str(REPO_ROOT) not in sys.path: + sys.path.insert(0, str(REPO_ROOT)) + +from chat.runtime import ChatRuntime +from core.cognition.pipeline import CognitiveTurnPipeline +from core.protocol import ( + CtpEpistemic, + CtpInvariant, + CtpProof, + JsonlEventReader, + JsonlEventSink, + canonical_bytes, + canonical_hash, + evidence_observed, + turn_completed, + turn_refused, + turn_requested, + verify_chain, +) +from generate.exhaustion import RefusalReason +from recognition.anti_unifier import derive_recognizer +from recognition.outcome import EvidenceSpan, FeatureBundle, NegativeEvidence + + +Decision = Literal["PROCEED", "STOP", "REFUSE"] + +SCENARIO_PATH = Path(__file__).with_name("scenarios.jsonl") +DEFAULT_OUTPUT_DIR = Path(__file__).with_name("out") + + +@dataclass(frozen=True, slots=True) +class Scenario: + scenario_id: str + description: str + simulated_input: dict[str, Any] + + +@dataclass(frozen=True, slots=True) +class DecisionRecord: + scenario_id: str + decision: Decision + reason: str + core_input: str + core_surface: str + core_refusal_reason: str + trace_hash: str + versor_condition: float + ctp_message_id: str + + +def _span(tokens: tuple[str, ...], start: int, end: int) -> EvidenceSpan: + return EvidenceSpan(start=start, end=end, text=" ".join(tokens[start:end])) + + +def _bundle( + tokens: tuple[str, ...], + *, + agent: str, + count: int, + unit: str, +) -> FeatureBundle: + return FeatureBundle.from_mapping( + { + "agent": (agent, _span(tokens, 0, 1)), + "count": (count, _span(tokens, 2, 3)), + "modality": ( + "simulated", + NegativeEvidence(0, len(tokens), "abstract fixture, not sensor data"), + ), + "polarity": ("+", NegativeEvidence(0, len(tokens), "no negator present")), + "relation": ("has", _span(tokens, 1, 2)), + "unit": (unit, _span(tokens, 3, 4)), + } + ) + + +def _recognizer(): + examples = [] + for tokens, agent, count in ( + (("alpha", "has", "1", "path"), "alpha", 1), + (("beta", "has", "0", "path"), "beta", 0), + ): + examples.append((tokens, _bundle(tokens, agent=agent, count=count, unit="path"))) + return derive_recognizer(examples) + + +def _load_scenarios(path: Path = SCENARIO_PATH) -> tuple[Scenario, ...]: + rows: list[Scenario] = [] + for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1): + if not line.strip(): + continue + raw = json.loads(line) + rows.append( + Scenario( + scenario_id=str(raw["scenario_id"]), + description=str(raw["description"]), + simulated_input=dict(raw["simulated_input"]), + ) + ) + if not rows: + raise ValueError(f"{path} did not contain scenarios") + return tuple(rows) + + +def _policy_decision(simulated_input: dict[str, Any]) -> tuple[Decision, str]: + required = { + "route_state", + "path_count", + "path_confidence", + "obstacle_state", + "operator_authorized", + "zone", + } + missing = sorted(required - simulated_input.keys()) + if missing: + return "REFUSE", f"under_determined: missing {','.join(missing)}" + if simulated_input["route_state"] != "mapped": + return "REFUSE", "under_determined: route is not mapped" + if not isinstance(simulated_input["path_confidence"], (int, float)): + return "REFUSE", "under_determined: path_confidence is not numeric" + if float(simulated_input["path_confidence"]) < 0.85: + return "REFUSE", "under_determined: path confidence below bound" + if simulated_input["operator_authorized"] is not True: + return "STOP", "operator not authorized" + if simulated_input["obstacle_state"] in {"occupied", "blocked"}: + return "STOP", f"path not clear: {simulated_input['obstacle_state']}" + if simulated_input["obstacle_state"] != "clear": + return "REFUSE", f"out_of_distribution: obstacle_state={simulated_input['obstacle_state']!r}" + if int(simulated_input["path_count"]) < 1: + return "STOP", "no admissible path in simulated record" + return "PROCEED", "mapped route, clear path, sufficient confidence" + + +def _core_input_for(scenario: Scenario, decision: Decision) -> str: + sim = scenario.simulated_input + if decision == "REFUSE": + return f"ambiguous telemetry for {scenario.scenario_id} cannot bind route evidence" + path_count = int(sim["path_count"]) + return f"{scenario.scenario_id.replace('-', '_')} has {path_count} path" + + +def _proof_for(result, *, replay_digest: str, decision: Decision) -> CtpProof: + invariants = ( + CtpInvariant( + name="versor_condition", + status="passed" if result.versor_condition < 1e-6 else "failed", + value=float(result.versor_condition), + threshold=1e-6, + ), + CtpInvariant( + name="decision_domain", + status="passed", + value=decision in {"PROCEED", "STOP", "REFUSE"}, + threshold=True, + detail="bounded proceed/stop/refuse domain", + ), + ) + return CtpProof( + trace_hash=result.trace_hash, + replay_digest=replay_digest, + admissibility_trace_hash=result.admissibility_trace_hash, + operator_invocation=result.operator_invocation, + versor_condition=float(result.versor_condition), + refusal_reason=result.refusal_reason, + invariants=invariants, + ) + + +def _run_once(scenarios: tuple[Scenario, ...], trace_path: Path) -> tuple[DecisionRecord, ...]: + if trace_path.exists(): + trace_path.unlink() + sink = JsonlEventSink(trace_path) + pipeline = CognitiveTurnPipeline(ChatRuntime(), recognizer=_recognizer()) + records: list[DecisionRecord] = [] + + for sequence_base, scenario in enumerate(scenarios): + decision, reason = _policy_decision(scenario.simulated_input) + core_input = _core_input_for(scenario, decision) + correlation_id = f"amr-demo:{scenario.scenario_id}" + + observed = evidence_observed( + "simulated_amr_fixture", + scenario.scenario_id, + correlation_id=correlation_id, + sequence=sequence_base * 10, + ) + requested = turn_requested( + core_input, + correlation_id=correlation_id, + sequence=sequence_base * 10 + 1, + ) + result = pipeline.run(core_input, max_tokens=4) + + if decision == "REFUSE" and result.refusal_reason != RefusalReason.RECOGNITION_REFUSED.value: + raise RuntimeError( + f"{scenario.scenario_id} was expected to materialize CORE recognition refusal; " + f"got {result.refusal_reason!r}" + ) + + replay_material = { + "core_refusal_reason": result.refusal_reason, + "decision": decision, + "reason": reason, + "scenario_id": scenario.scenario_id, + "trace_hash": result.trace_hash, + } + replay_digest = canonical_hash(replay_material) + epistemic = CtpEpistemic( + state="REFUSED" if decision == "REFUSE" else "GROUNDED", + grounding_source=( + "core_recognition_refusal" + if decision == "REFUSE" + else "simulated_fixture_plus_core_trace" + ), + normative_clearance="UNASSESSABLE" if decision == "REFUSE" else "CLEARED", + ) + proof = _proof_for(result, replay_digest=replay_digest, decision=decision) + if decision == "REFUSE": + terminal = turn_refused( + refusal_reason=result.refusal_reason, + trace_hash=result.trace_hash, + epistemic=epistemic, + causation_id=requested.message_id, + correlation_id=correlation_id, + sequence=sequence_base * 10 + 2, + ) + else: + terminal = turn_completed( + surface=f"decision={decision}; reason={reason}", + trace_hash=result.trace_hash, + epistemic=epistemic, + causation_id=requested.message_id, + correlation_id=correlation_id, + sequence=sequence_base * 10 + 2, + proof=proof, + ) + + sink.append(observed) + sink.append(requested) + sink.append(terminal) + records.append( + DecisionRecord( + scenario_id=scenario.scenario_id, + decision=decision, + reason=reason, + core_input=core_input, + core_surface=result.surface, + core_refusal_reason=result.refusal_reason, + trace_hash=result.trace_hash, + versor_condition=float(result.versor_condition), + ctp_message_id=terminal.message_id, + ) + ) + + verify_chain(tuple(JsonlEventReader(trace_path))) + return tuple(records) + + +def run_demo(output_dir: Path = DEFAULT_OUTPUT_DIR) -> dict[str, Any]: + output_dir.mkdir(parents=True, exist_ok=True) + scenarios = _load_scenarios() + trace_a = output_dir / "trace_a.jsonl" + trace_b = output_dir / "trace_b.jsonl" + records_a = _run_once(scenarios, trace_a) + records_b = _run_once(scenarios, trace_b) + + byte_identical_replay = trace_a.read_bytes() == trace_b.read_bytes() + if not byte_identical_replay: + raise RuntimeError("fresh-runtime replay traces were not byte-identical") + if records_a != records_b: + raise RuntimeError("fresh-runtime decision records diverged") + + decisions = [r.decision for r in records_a] + payload = { + "demo_id": "amr_decision_substrate", + "scope": { + "core_role": "decision/refusal/replay accountability substrate", + "not_claimed": [ + "perception", + "SLAM/localization", + "motion planning", + "motor control", + "robot fleet integration", + ], + "input_kind": "simulated abstract AMR situation records", + }, + "claims": { + "bounded_decision_domain": sorted(set(decisions)) == ["PROCEED", "REFUSE", "STOP"], + "refuse_path_present": "REFUSE" in decisions, + "byte_identical_replay": byte_identical_replay, + "all_versors_closed": all(r.versor_condition < 1e-6 for r in records_a), + }, + "records": [asdict(r) for r in records_a], + "trace_a_sha256": hashlib.sha256(trace_a.read_bytes()).hexdigest(), + "trace_b_sha256": hashlib.sha256(trace_b.read_bytes()).hexdigest(), + } + summary_path = output_dir / "summary.json" + summary_path.write_bytes(canonical_bytes(payload)) + return payload + + +def main() -> int: + payload = run_demo() + print(json.dumps(payload, indent=2, sort_keys=True)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/demos/amr_decision_substrate/scenarios.jsonl b/demos/amr_decision_substrate/scenarios.jsonl new file mode 100644 index 00000000..bb920037 --- /dev/null +++ b/demos/amr_decision_substrate/scenarios.jsonl @@ -0,0 +1,3 @@ +{"scenario_id":"sim-clear-corridor","description":"Simulated clear corridor with a mapped route and sufficient confidence.","simulated_input":{"route_state":"mapped","path_count":1,"path_confidence":0.94,"obstacle_state":"clear","operator_authorized":true,"zone":"public_floor"}} +{"scenario_id":"sim-occupied-aisle","description":"Simulated occupied aisle; the route is known, but the path is blocked by an abstract obstacle state.","simulated_input":{"route_state":"mapped","path_count":1,"path_confidence":0.91,"obstacle_state":"occupied","operator_authorized":true,"zone":"public_floor"}} +{"scenario_id":"sim-underdetermined","description":"Simulated under-determined record; the obstacle state is absent, so the policy cannot decide safely.","simulated_input":{"route_state":"mapped","path_count":1,"path_confidence":0.88,"operator_authorized":true,"zone":"public_floor"}} diff --git a/docs/research/brain_corp_dossier.md b/docs/research/brain_corp_dossier.md new file mode 100644 index 00000000..8c197520 --- /dev/null +++ b/docs/research/brain_corp_dossier.md @@ -0,0 +1,157 @@ +# Brain Corp Dossier + +This is external research only. It does not assert CORE benchmark results, +capability numbers, or claims-ledger facts. + +## Snapshot + +Brain Corp presents BrainOS as a deployed autonomy platform for commercial +robots, with applications across cleaning, inventory, remote site management, +and newer physical-AI directions. Public materials position BrainOS as a +platform combining robotic autonomy, analytics/operations management, and +autonomy services. The BrainOS page states that the platform integrates a +sensor kit, UL-certified controller, and autonomy software for perception, +motion planning, localization, and navigation. [BrainOS platform](https://www.braincorp.com/brainos) + +Brain Corp's safety page emphasizes computer vision, 3D LiDAR, real-time path +adjustment, global replanning, path optimization, redundant safety systems, and +real-time obstacle detection. It also states the controller has independent UL +60730-1 and SIL2 verification and gives public fleet scale/reliability claims. +[Brain Corp safety](https://www.braincorp.com/safety) + +## Public Architecture Reading + +The public architecture is a deployed robotics autonomy stack: + +- Sensors and perception: computer vision and 3D LiDAR are explicitly named in + safety materials. +- Localization/navigation/planning: BrainOS describes perception, precise motion + planning, localization, and advanced navigation. +- Runtime safety: the safety page describes layered and redundant safety, plus + obstacle detection in dynamic environments. +- Fleet/ops layer: BrainOS includes BrainOS Mobile, Fleet Ops Portal, weekly + summaries, remote monitoring/diagnostics, and remote route optimization. +- Data flywheel: BrainOS describes "crowdsource learning," where field robot + experience is applied across the fleet. + +The important CTO inference: Brain Corp does not need a generic "robot brain." +They already operate a vertically integrated autonomy-plus-operations platform. +Any CORE conversation must be about a narrow substrate underneath or adjacent to +decision accountability, not replacing their stack. + +## Safety and Determinism Positioning + +Brain Corp's public "deterministic safety" equivalent sits in conventional +robotics safety architecture: sensors, obstacle detection, real-time replanning, +multi-layer redundancy, controller certification, and fleet operational support. +Public materials do not describe an inspectable cognitive trace substrate that +turns an abstract decision into a replayable refusal/proceed/stop proof. That is +the possible opening for CORE, but it should be framed as a gap hypothesis, not +as a proven product-market fit. + +## Partnerships and Commercial Signals + +Tennant is the clearest floor-care partner signal. Tennant and Brain Corp +announced an exclusive technology agreement in February 2024 to accelerate +robotic floor-cleaning innovation. Tennant said Brain Corp technology powered +more than 6,500 Tennant cleaning robots in the field and described the X4 ROVR +as the first of planned future AMR cleaning products powered by Brain Corp's +next-generation technology for Tennant equipment. [Tennant/Brain Corp agreement](https://investors.tennantco.com/news/news-details/2024/Tennant-Company-and-Brain-Corp-Sign-Exclusive-Technology-Agreement-To-Accelerate-Robotic-Floor-Cleaning-Innovation-and-Adoption/default.aspx) + +Tennant's X4 ROVR release says the machine is powered by the next-generation +BrainOS Robotics Platform and emphasizes computer vision, compact dimensions, +and operation in narrow/congested spaces. [X4 ROVR release](https://investors.tennantco.com/news/news-details/2024/Tennant-Announces-Full-Specification--Capabilities-of-X4-ROVR-Autonomous-Floor-Cleaning-Machine-its-First-Purpose-Built-Robotic-Scrubber-/default.aspx) + +SoftBank Robotics' Whiz materials also name BrainOS. SoftBank Robotics America +describes Whiz as powered by BrainOS, and SoftBank Robotics Group describes +Whiz/Whiz i as co-developed with Brain Corp in 2017. [SoftBank Robotics Whiz](https://us.softbankrobotics.com/whiz), [SoftBank Robotics solution page](https://www.softbankrobotics.com/solution/) + +Brain Corp also announced a May 20, 2026 UC San Diego collaboration focused on +semantic mapping and contextual grounding for physical AI. That announcement is +especially relevant because it names the same adjacent problem space where CORE +should avoid overclaiming: contextual understanding, grounding, and reliability +in complex physical environments. [Brain Corp/UC San Diego](https://www.braincorp.com/resources/brain-corp-and-uc-san-diego-partner-to-advance-the-foundational-intelligence-layer-for-physical-ai) + +## Eugene Izhikevich Lineage + +Brain Corp's own about page identifies Dr. Eugene Izhikevich as co-founder and +chairman. It says the company began in 2009 with computational neuroscientists +providing research services, guided by Izhikevich, and later launched BrainOS in +2014. The same page ties Izhikevich to spiking-network theory, a large +thalamo-cortical model, the Neurosciences Institute, and Scholarpedia. +[Brain Corp about](https://www.braincorp.com/about) + +Takeaway for the CTO conversation: do not present CORE's geometric/cognitive +language as exotic relative to Brain Corp. Their origin story already includes +computational neuroscience and brain-inspired robotics. The differentiator must +be a concrete accountable substrate, not philosophical novelty. + +## Patent Signals + +US11467602B2, assigned to Brain Corp, is titled "Systems and methods for +training a robot to autonomously travel a route." The patent page names route, +map, robot, and user as key terms and describes learning a route by +demonstration, mapping/localization, autonomous navigation, sensor data, +actuator association, map evaluation/correction, and cases where the robot +determines not to autonomously navigate a portion of a route. [US11467602B2](https://patents.google.com/patent/US11467602B2/en) + +This patent signal reinforces that Brain Corp's core lane is teach/repeat, +mapping, localization, navigation, route quality, and commercial cleaning +robotics. CORE should not enter the conversation as a competing route-learning +or navigation system. + +## Adjacent Players + +- Avidbots: autonomous floor-care competitor. Avidbots public autonomy material + says its proprietary AI software powers Neo for autonomous floor scrubbing. + [Avidbots autonomy PDF](https://avidbots.com/assets/Knowledge/Avidbots_Autonomy.pdf) +- SoftBank Robotics: Whiz is a commercial cleaning robot line, with official + pages naming BrainOS and Brain Corp involvement. [Whiz](https://us.softbankrobotics.com/whiz) +- Locus Robotics: warehouse AMR/orchestration competitor in a different + vertical. Locus publicly describes AMRs, LocusONE orchestration, Locus Origin, + Locus Vector, and newer Locus Array for more autonomous fulfillment. + [Locus Robotics](https://www.locusrobotics.com/) + +## Gap CORE Can Honestly Target + +The precise gap is not perception, not navigation, not motion planning, and not +fleet operations. Brain Corp already owns those deployed surfaces. + +The possible gap is a substrate-level accountability layer for bounded decisions: + +- preserve an abstract decision record as a deterministic trace; +- distinguish proceed, stop, and refusal; +- refuse under-determined input rather than forcing a fluent answer; +- make replay equality a first-class artifact; +- expose invariant checks and refusal reason in a canonical protocol. + +The current AMR demo should be described only as a preparation artifact that +shows this shape over simulated records. It does not prove deployment readiness. + +## Conversation Posture + +Strong opening: + +"BrainOS is the robotics stack. We are not here to claim perception, planning, +or motor control. We prepared a tiny simulated AMR-adjacent accountability demo +to discuss whether a deterministic refusal/replay substrate could be useful +beneath bounded decisions in a system like yours." + +Weak opening: + +"CORE is a new kind of robot intelligence that could sit under BrainOS." + +## Source List + +- [BrainOS platform](https://www.braincorp.com/brainos) +- [Brain Corp safety](https://www.braincorp.com/safety) +- [Brain Corp about](https://www.braincorp.com/about) +- [Brain Corp / UC San Diego physical AI collaboration](https://www.braincorp.com/resources/brain-corp-and-uc-san-diego-partner-to-advance-the-foundational-intelligence-layer-for-physical-ai) +- [Tennant / Brain Corp exclusive technology agreement](https://investors.tennantco.com/news/news-details/2024/Tennant-Company-and-Brain-Corp-Sign-Exclusive-Technology-Agreement-To-Accelerate-Robotic-Floor-Cleaning-Innovation-and-Adoption/default.aspx) +- [Tennant X4 ROVR release](https://investors.tennantco.com/news/news-details/2024/Tennant-Announces-Full-Specification--Capabilities-of-X4-ROVR-Autonomous-Floor-Cleaning-Machine-its-First-Purpose-Built-Robotic-Scrubber-/default.aspx) +- [Tennant T380AMR product page](https://www.tennantco.com/en_us/1/machines/scrubbers/product.t380amr.robotic-floor-scrubber.M-T380AMR.html) +- [SoftBank Robotics Whiz](https://us.softbankrobotics.com/whiz) +- [SoftBank Robotics solution page](https://www.softbankrobotics.com/solution/) +- [US11467602B2 patent](https://patents.google.com/patent/US11467602B2/en) +- [Avidbots autonomy PDF](https://avidbots.com/assets/Knowledge/Avidbots_Autonomy.pdf) +- [Locus Robotics](https://www.locusrobotics.com/) diff --git a/docs/research/cto_pressure_test.md b/docs/research/cto_pressure_test.md new file mode 100644 index 00000000..c113609f --- /dev/null +++ b/docs/research/cto_pressure_test.md @@ -0,0 +1,169 @@ +# Skeptical CTO Pressure Test + +Purpose: a hard-question rubric for a first technical conversation with Brain +Corp. The standard is honesty under pressure. Any answer that converts "not yet" +into "basically done" fails the product. + +## 1. Where is the external validation? + +Honest answer: + +CORE has internal deterministic evidence and demos. External validation is not +yet established unless and until a named third party has reviewed a specific +artifact. For any benchmark, capability, or safety result, use +`[VERIFY vs claims ledger]` rather than quoting numbers from memory. + +Weak answer to avoid: + +We have strong results and are already ahead of conventional systems. The exact +external validation can come later. + +## 2. Show me working vision and motor control. + +Honest answer: + +Do not claim working CORE-native vision or motor. The current robotics-adjacent +demo is an abstract decision/accountability substrate over simulated situation +records. It is not perception, SLAM, localization, path planning, motor control, +or a robot integration. + +Weak answer to avoid: + +The same substrate naturally extends to vision and motor, so this is basically +a robot brain. + +## 3. Why should Brain Corp care if BrainOS already handles perception, +navigation, safety, fleet telemetry, and operations? + +Honest answer: + +They should not replace BrainOS with CORE. The possible fit is beneath or beside +the autonomy stack: replayable decision provenance, refusal-on-ambiguity, and +accountability records for bounded decisions where a system must show why it +proceeded, stopped, or refused. BrainOS is the deployed robotics platform; CORE +is only a candidate substrate for traceable cognition/control evidence. + +Weak answer to avoid: + +BrainOS is conventional robotics infrastructure and CORE is the more advanced +foundation. + +## 4. What exactly works today? + +Honest answer: + +Say only what the prepared demo proves: a simulated AMR-style situation record +can be reduced into `PROCEED`, `STOP`, or `REFUSE`; the under-determined case +materializes a CORE refusal reason; two fresh runs produce byte-identical replay +artifacts; the demo preserves the versor closure invariant. Anything beyond that +is roadmap or hypothesis. + +Weak answer to avoid: + +This demonstrates reliable robotics decision-making. + +## 5. Are you using LLMs, stochastic generation, or hidden heuristics? + +Honest answer: + +For the demo, the policy reducer is explicit and tiny; CORE supplies the real +runtime trace/refusal/replay surfaces. The demo should name what is simulated +and should not hide the reducer as "emergent cognition." If any future surface +uses stochastic models, that must be disclosed as outside CORE's deterministic +substrate. + +Weak answer to avoid: + +No heuristics; the geometry handles the decision. + +## 6. What happens on out-of-distribution or ambiguous input? + +Honest answer: + +The demo refuses. More generally, the desired contract is refuse rather than +guess. If a current component fails to refuse where it should, that is a defect +to report, not a behavior to explain away. + +Weak answer to avoid: + +It generalizes gracefully because the manifold structure is robust. + +## 7. Who besides the founder has verified this? + +Honest answer: + +Name only actual reviewers, tests, audits, or PRs that have occurred. If the +answer is "not yet externally verified," say that. The Brain Corp conversation +is preparation for scrutiny, not proof of validation. + +Weak answer to avoid: + +Several technical people have looked at it and found it promising. + +## 8. Why is this not just a fancy audit log? + +Honest answer: + +An audit log records what happened. The intended CORE distinction is that +decision, refusal, trace hash, invariant checks, and replay equality are +load-bearing in the runtime contract. The current demo shows the trace/replay +surface, not a full robotics-grade control proof. + +Weak answer to avoid: + +Audit logs are passive; CORE is intelligent. + +## 9. Can this improve Brain Corp's deployed safety case? + +Honest answer: + +Not by assertion. The narrow possible value is a secondary accountability layer +that can refuse under-determined decisions and replay the same trace +byte-for-byte. Whether that helps a deployed safety case requires Brain Corp's +requirements, certification constraints, and integration boundaries. + +Weak answer to avoid: + +Yes, because deterministic refusal is inherently safer. + +## 10. What would a real pilot have to prove? + +Honest answer: + +A credible pilot would need a bounded decision interface, a written non-goal +list, replayable traces, refusal cases, operator-review flow, and a comparison +against an existing BrainOS decision/audit mechanism. It would also need failure +criteria: if CORE cannot add clearer accountability without increasing +integration risk, the pilot should stop. + +Weak answer to avoid: + +Give us data and we can show broad improvement. + +## 11. What are the hardest objections? + +Honest answer: + +- CORE does not currently demonstrate robot perception or motor emission. +- The demo uses simulated facts, not sensors. +- External validation is pending. +- The domain-policy reducer is not CORE-native robotics intelligence. +- Brain Corp already has a mature deployed stack; CORE must earn a narrow + interface, not demand architectural replacement. + +Weak answer to avoid: + +The objections are mostly about maturity, not architecture. + +## 12. What should Opus's brief be graded against? + +It should pass these checks: + +- No benchmark numbers unless copied from the approved claims ledger. +- No claim that CORE has working vision/motor. +- No implication that BrainOS is obsolete. +- No hidden slide from simulated demo to real robot readiness. +- Clear distinction between substrate, policy reducer, perception, planning, + actuation, and fleet operations. +- Every strong claim has either a cited external source, a repo artifact, or + `[VERIFY vs claims ledger]`. From f3680aa302d1c671913e0023d530ab8c6b82b253 Mon Sep 17 00:00:00 2001 From: Shay Date: Tue, 2 Jun 2026 10:00:46 -0700 Subject: [PATCH 2/3] reconcile amr demo wording with claims ledger --- demos/amr_decision_substrate/README.md | 7 +++++ docs/research/brain_corp_dossier.md | 12 ++++++-- docs/research/cto_pressure_test.md | 39 +++++++++++++++++++------- 3 files changed, 45 insertions(+), 13 deletions(-) diff --git a/demos/amr_decision_substrate/README.md b/demos/amr_decision_substrate/README.md index c71a241d..5179c71d 100644 --- a/demos/amr_decision_substrate/README.md +++ b/demos/amr_decision_substrate/README.md @@ -7,6 +7,13 @@ accountability substrate around a bounded AMR-style proceed / stop / refuse choice. The inputs are not camera, LiDAR, odometry, SLAM, localization, motor, or fleet-control data. +Claims-ledger framing: this is a preparation artifact over simulated records. +It is not deployment readiness, not perception, not motion planning, and not +motor control. The demo proves only its local trace/refusal/replay surface over +these fixtures. It does not imply a CORE expert domain, a robotics capability +claim, or working vision/motor. Per the ledger, text is the active capability; +audio is substrate with the gate CLOSED; vision and motor are proposed only. + What is real CORE here: - `ChatRuntime` diff --git a/docs/research/brain_corp_dossier.md b/docs/research/brain_corp_dossier.md index 8c197520..e4e2e0da 100644 --- a/docs/research/brain_corp_dossier.md +++ b/docs/research/brain_corp_dossier.md @@ -1,7 +1,7 @@ # Brain Corp Dossier -This is external research only. It does not assert CORE benchmark results, -capability numbers, or claims-ledger facts. +This is primarily external research. When CORE status is mentioned for +conversation framing, it is reconciled to `docs/claims_ledger.md` on main. ## Snapshot @@ -127,6 +127,11 @@ The possible gap is a substrate-level accountability layer for bounded decisions The current AMR demo should be described only as a preparation artifact that shows this shape over simulated records. It does not prove deployment readiness. +Ledger framing keeps that boundary sharp: no CORE domain is at `expert`; +`audit-passed` means claim-shape compliance, not raw capability; text is an +active modality, audio is substrate with its gate CLOSED, and vision/motor are +proposed only. Determinism should be framed as byte-stable trace/digest evidence +and fail-closed drift detection, not robotics-grade control. ## Conversation Posture @@ -135,7 +140,8 @@ Strong opening: "BrainOS is the robotics stack. We are not here to claim perception, planning, or motor control. We prepared a tiny simulated AMR-adjacent accountability demo to discuss whether a deterministic refusal/replay substrate could be useful -beneath bounded decisions in a system like yours." +beneath bounded decisions in a system like yours. The demo is a preparation +artifact over simulated records, not deployment readiness." Weak opening: diff --git a/docs/research/cto_pressure_test.md b/docs/research/cto_pressure_test.md index c113609f..b28561ce 100644 --- a/docs/research/cto_pressure_test.md +++ b/docs/research/cto_pressure_test.md @@ -8,10 +8,13 @@ into "basically done" fails the product. Honest answer: -CORE has internal deterministic evidence and demos. External validation is not -yet established unless and until a named third party has reviewed a specific -artifact. For any benchmark, capability, or safety result, use -`[VERIFY vs claims ledger]` rather than quoting numbers from memory. +CORE has internal deterministic evidence and demos, but external validation is +not established unless a named third party has reviewed a specific artifact. +The claims ledger says no domain is at `expert`; `mathematics_logic`, +`physics`, and `systems_software` are `audit-passed`, with the prior expert +promotion fail-closed-reverted. `audit-passed` means CORE claim-shape compliance +per ADR-0113: signed digest, replay determinism, typed refusal, exact recall, +and grounding provenance. It is not a raw-capability or expert-level claim. Weak answer to avoid: @@ -25,7 +28,9 @@ Honest answer: Do not claim working CORE-native vision or motor. The current robotics-adjacent demo is an abstract decision/accountability substrate over simulated situation records. It is not perception, SLAM, localization, path planning, motor control, -or a robot integration. +or a robot integration. Ledger multimodal status is: text is an active +capability; audio is substrate with the capability gate CLOSED; vision and +motor are proposed only. Weak answer to avoid: @@ -55,8 +60,12 @@ Honest answer: Say only what the prepared demo proves: a simulated AMR-style situation record can be reduced into `PROCEED`, `STOP`, or `REFUSE`; the under-determined case materializes a CORE refusal reason; two fresh runs produce byte-identical replay -artifacts; the demo preserves the versor closure invariant. Anything beyond that -is roadmap or hypothesis. +artifacts; the demo preserves the versor closure invariant. Ledger-wide +determinism framing is stronger and still bounded: byte-identical replay/digest +evidence is stable across processes and `PYTHONHASHSEED`; the expert revert was +a single-source evidence-drift in a non-gating coverage metric, and the system +caught that drift by failing closed to `audit-passed`, never to a false expert. +None of this proves robotics-grade control. Weak answer to avoid: @@ -82,7 +91,13 @@ Honest answer: The demo refuses. More generally, the desired contract is refuse rather than guess. If a current component fails to refuse where it should, that is a defect -to report, not a behavior to explain away. +to report, not a behavior to explain away. Use the ledger's exact GSM8K framing +if the subject comes up: A sealed-real `0/0/1319` is the honest external number, +showing zero-confabulation discipline plus an honest coverage gap, not an +accuracy result; B synthetic-public `150/150/0` is CORE-authored and never "100% +on GSM8K"; C train_sample `6/44/0` has exit-criterion NOT met, and the stricter +probe reads `4/46` on the same 50; D composite `185/14/40/50 wrong=0` is +CORE-authored and currently reverted. Weak answer to avoid: @@ -134,7 +149,9 @@ A credible pilot would need a bounded decision interface, a written non-goal list, replayable traces, refusal cases, operator-review flow, and a comparison against an existing BrainOS decision/audit mechanism. It would also need failure criteria: if CORE cannot add clearer accountability without increasing -integration risk, the pilot should stop. +integration risk, the pilot should stop. Single-signer attestation is also a +known boundary: the reviewer registry has one signer, `shay-j`, and a partner +may reasonably probe that. Weak answer to avoid: @@ -161,9 +178,11 @@ It should pass these checks: - No benchmark numbers unless copied from the approved claims ledger. - No claim that CORE has working vision/motor. +- No claim that any domain is `expert`; `audit-passed` is claim-shape compliance, + not expert capability. - No implication that BrainOS is obsolete. - No hidden slide from simulated demo to real robot readiness. - Clear distinction between substrate, policy reducer, perception, planning, actuation, and fleet operations. - Every strong claim has either a cited external source, a repo artifact, or - `[VERIFY vs claims ledger]`. + the exact claims-ledger value and framing. From f0c270fded953ba35d9abf6a2e92d5bb4d06b175 Mon Sep 17 00:00:00 2001 From: Shay Date: Tue, 2 Jun 2026 10:22:18 -0700 Subject: [PATCH 3/3] harden amr demo replay fixture --- demos/amr_decision_substrate/run_demo.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/demos/amr_decision_substrate/run_demo.py b/demos/amr_decision_substrate/run_demo.py index d1b7e4f0..f1da847c 100644 --- a/demos/amr_decision_substrate/run_demo.py +++ b/demos/amr_decision_substrate/run_demo.py @@ -126,7 +126,9 @@ def _policy_decision(simulated_input: dict[str, Any]) -> tuple[Decision, str]: return "REFUSE", f"under_determined: missing {','.join(missing)}" if simulated_input["route_state"] != "mapped": return "REFUSE", "under_determined: route is not mapped" - if not isinstance(simulated_input["path_confidence"], (int, float)): + if isinstance(simulated_input["path_confidence"], bool) or not isinstance( + simulated_input["path_confidence"], (int, float) + ): return "REFUSE", "under_determined: path_confidence is not numeric" if float(simulated_input["path_confidence"]) < 0.85: return "REFUSE", "under_determined: path confidence below bound" @@ -136,6 +138,10 @@ def _policy_decision(simulated_input: dict[str, Any]) -> tuple[Decision, str]: return "STOP", f"path not clear: {simulated_input['obstacle_state']}" if simulated_input["obstacle_state"] != "clear": return "REFUSE", f"out_of_distribution: obstacle_state={simulated_input['obstacle_state']!r}" + if isinstance(simulated_input["path_count"], bool) or not isinstance( + simulated_input["path_count"], int + ): + return "REFUSE", "under_determined: path_count is not numeric" if int(simulated_input["path_count"]) < 1: return "STOP", "no admissible path in simulated record" return "PROCEED", "mapped route, clear path, sufficient confidence" @@ -180,7 +186,7 @@ def _run_once(scenarios: tuple[Scenario, ...], trace_path: Path) -> tuple[Decisi if trace_path.exists(): trace_path.unlink() sink = JsonlEventSink(trace_path) - pipeline = CognitiveTurnPipeline(ChatRuntime(), recognizer=_recognizer()) + pipeline = CognitiveTurnPipeline(ChatRuntime(no_load_state=True), recognizer=_recognizer()) records: list[DecisionRecord] = [] for sequence_base, scenario in enumerate(scenarios):