Umst Concrete Cartridge

SPDX-FileCopyrightText: 2026 Santosh Prabhu Shenbagamoorthy and Santhosh Shyamsundar SPDX-License-Identifier: MIT

UMST Concrete Cartridge

Repository: tytolabs/umst-concrete-cartridge — cementitious matter cartridge on the UMST Manifold.

This ecosystem is dedicated to the thousands of unnamed contributors who wrote formal proofs, maintained open-source compilers, and built mathematical libraries for years — often without evidence that any of it would be used beyond pure theory. They chose to make their work free, because they understood that knowledge about physical reality cannot be owned. Whatever this system achieves is yours.

Cartridge in plain words

Underneath this cartridge is UMST — the Unified Material-State Tensor — a single mathematical object that holds a material's full state (substance, processes, environment, geometry, and time) and only lets it change in ways physics actually permits. Every proposed change passes through the thermodynamic admissibility gate: conserve mass, never produce negative dissipation, or be rejected — no creating strength or energy from nothing.

This concrete cartridge is the part that knows cement. It supplies chemical-physical closures for hydration, rheology, and load-bearing behaviour, calibrated against measured datasets, and plugs into the manifold through IScienceCartridge. Instead of curve-fitting past tests alone, it evaluates constitutive pipelines on the carrier — and agent contributions require a gate PASS before memory ingest (§9).

The library exposes gated constitutive prediction, mix audit, print-stability and deposition physics in simulation, and spatial structural shape optimizations under load limits. Studio TYTO has not yet run this cartridge through a full on-robot, on-extruder physical print campaign**; what follows describes what the code is built to support and what we hope to demonstrate once hardware, materials plant, and control stacks are integrated.

Scope: Mix audits, notebooks, MCP tools, mechanics/topology surrogates (e.g. the RC beam animation below), and constitutive kernels are exercised in-repo. Closed-loop extrusion on a real printer remains an integration target, not a completed end-to-end claim here. Formal-catalog module counts are not owned by this README — see §8 (link the manifold lock; do not hardcode a drifting number).

Surrogate animation only — not a physical print or lab measurement. 32×8 RC beam: adjoint compliance topology optimization with a fixed bottom rebar row; yellow density (ρ) from the mechanics façade. Role. A Rust workspace that implements cementitious constitutive closures and mounts them on the manifold through typed ports (IScienceCartridge, …), exposing CLI / Python / stdio-MCP surfaces for mix prediction, audit, and gate-validated agent workflows.

The gate idea. Every proposed mix/state change is subject to the thermodynamic admissibility gate (reduced Clausius–Duhem + Landauer cost bounds on the shared stack): conserve mass, never produce negative dissipation, or be rejected with structured remediation — no silent failure.

Shared stack (matter · knowing · acting · time)

These public repos share one thermodynamic admissibility gate, applied across domains:

Sibling links only — no paper-series arc naming in this README. Already-public per-repo DOI badges stay where they exist; this cartridge does not invent new ones here.

Ports (categorical — real symbols)

Top-level map

Detailed outline — every entry links to a stable anchor (README.md#…); collapsible sections use <details> but share the same deep-link fragments.

• §1 Physical and Chemical Formulations
  • 1.1 Mounting on the UMST carrier
  • 1.2 Grounding contract: derived, measured, and grounded constants
  • In-§1 narrative bullets (nanoscale, Arrhenius, DFT, GWP)
• §2 Cross-Domain Integration Specifications
  • 2.1 Spatial Topologies & Structural Design
  • 2.2 Material Auditing & Mix Optimization
  • 2.3 Robotic Manufacturing & 3D Printing
  • 2.4 Structural Verification & Systems Integration
• §3 Industrial CAD/CAM/CAE Pipeline Integration
  • Integration table (BIM, FEM, Robotic CAM, PLM)
• §4 Exhaustive Architecture Topology
  • Repository tree
• §5 Constitutive Chemistry & Durability Closures
  • Summary closure table
  • 5.1 Nanoscale DLVO & ITZ
  • 5.2 Creep & capillary shrinkage
  • 5.3 Self-heal potential
  • 5.4 Robotic printability & buckling
  • 5.5 GWP & dynamic sequestration
• §6 Quick start (~60 s)
  • Copy-paste: CLI, Python, MCP
  • Surface A: The CLI
  • Surface B: Python & Notebooks
  • Surface C: The MCP Server
• §7 Build, Test, and CI Parity (For Integrators)
  • Integrator commands & feature matrix
  • Feature Flags (Cartridge)
• §8 Deep documentation and citations
  • Linked docs list in §8 body
• §9 Special Protocol: Note to Autonomous AI Agents & Systems
  • 9.1 Shared stack (gate spine)
  • 9.2 Hot arena vs cold edge
  • 9.3 Gate contract
  • 9.4 Working contract
  • 9.5 Operational mapping
  • 9.6 Proposed (not yet built)
  • 9.7 Principles
• §11 Conclusion: Inferences & Forward Path
  • This repository demonstrates
  • Inferences from the work
• Related repositories
• Authors
• Acknowledgments
• Contributing
• Citation
• License

Each ## / ### heading on GitHub gets a stable anchor (the fragment after # in README.md#anchor-name). Paste tytolabs/umst-concrete-cartridge/blob/main/README.md#… in issues and PRs the same way.

#1-physical-and-chemical-formulations
#11-mounting-on-the-umst-carrier
#12-grounding-contract-derived-measured-and-grounded-constants
#2-cross-domain-integration-specifications
#21-spatial-topologies--structural-design
#22-material-auditing--mix-optimization
#23-robotic-manufacturing--3d-printing
#24-structural-verification--systems-integration
#3-industrial-cadcamcae-pipeline-integration
#4-exhaustive-architecture-topology
#repository-tree
#5-constitutive-chemistry--durability-closures
#51-nanoscale-dlvo-slurry--itz-boundary-mechanics
#52-long-term-creep-compliance--capillary-shrinkage
#53-calcite-crystallization--self-healing-kinetics
#54-robotic-printability--buckling-limit-envelopes
#55-global-warming-potential-gwp--dynamic-sequestration
#6-quick-start-time-to-value--60-seconds
#quick-start-copy-paste-cli-python-mcp
#surface-a-the-cli-for-massive-dataset-audits
#surface-b-python--notebooks-for-data-scientists-and-cad-integration
#surface-c-the-mcp-server-for-autonomous-agents--ides
#7-build-test-and-ci-parity-for-integrators
#integrator-commands--feature-matrix
#feature-flags-cartridge
#8-deep-documentation-and-citations
#9-special-protocol-note-to-autonomous-ai-agents--systems
#91-shared-stack-gate-spine
#92-hot-arena-vs-cold-edge-performance-honesty
#93-gate-contract-no-silent-failure
#94-working-contract-load-bearing
#95-operational-mapping
#96-proposed-not-yet-built
#97-principles
#11-conclusion-inferences--forward-path
#this-repository-demonstrates
#inferences-from-the-work
#related-repositories
#authors
#acknowledgments
#contributing
#citation
#license

1. Physical and Chemical Formulations

1.1 Mounting on the UMST carrier

This cartridge implements IScienceCartridge on the UMST Manifold and reads/writes the UMST carrier — the unified per-voxel state bundle described in the manifold README as an extensible pipeline (64 scalar lanes in today’s default tensor layout; lane semantics stay versioned with schema/ and crate releases). Nothing here assumes a fixed “64 forever”; it assumes a stable contract between mix JSON, Rust tensors, and CI.

1.2 Grounding contract: derived, measured, and grounded constants

Every constant is derived, measured, or grounded in truth — not a silent knob. The same obligation class as UMST Manifold §1.4, applied to cementitious closures:

• Derived — Arrhenius forms, Vinet bulk modulus, GWP linear mix rule g_i, and other coefficients that follow from constitutive structure and dimensional analysis once material inputs are fixed.
• Measured — Nano-indentation, UCI / Zenodo / ASTM-style benchmarks, site w / h bead logs, and rows in bundled calibration/ profiles and datasets/ CSVs matched by tests/calibration/dataset_metrics.rs (record what was measured, where, and under which schema version).
• Grounded — DFT-backed anchors in mix JSON, literature-cited parameters in docs/Constitutive-Equations.md, explicit uncertainty bands in docs/Validation.md, and CI regression pins so drift is visible.

Empirical numbers are not free mid-training knobs: they carry provenance (dataset, paper, profile TOML). If a value is fit, the fit range and admissibility envelope are part of the contract umst audit and related tools enforce.

Physics scales by composition under the second law. Constitutive closures (hydration, creep, printability, carbonation, …) do not run as a grab bag of heuristics: they compose into the same UMST carrier the manifold integrates, and admissible trajectories are those the manifold’s thermodynamic gate accepts—local dissipation and entropy production stay in the inequality class inherited from the manifold’s Clausius–Duhem formulation (manifold §1.2). Stacking chemistry + mechanics + transport means re-applying that contract at each composed step, not weakening it at the cartridge boundary.

“Proven” here = documented invariants + tests + formal stack where shared. Cement-specific lemmas live in this repo’s docs and regression suites; DEC conservation and shared proof anchors live on the manifold and in umst-formal. We separate machine-checked kernel obligations from constitutive calibration evidence so neither is confused for the other.

To optimize a structural mix, we must follow the physical processes that govern its life cycle. The engine calculates mechanical properties by simulating the chemical reactions occurring at the microscopic scale:

• No Guessing at the Nanoscale: When we predict how strong or stiff a material is, we do not guess based on soft averages. Our calculations are anchored in the fundamental atomic pressure-volume relationship of crystals (using a physical model called Pellenq's Vinet bulk modulus paired with nano-indentation tests): The Outcome: When the engine predicts the load-bearing capacity of a new, untested concrete mix, the prediction is anchored in immutable atomic physics (<source media="(prefers-color-scheme: dark)" srcset=" alt="B_0" src=" style="vertical-align:middle">, <source media="(prefers-color-scheme: dark)" srcset=" alt="V_0" src=" style="vertical-align:middle">), keeping predictions inside the physically admissible envelope.
• Accurate Thermal Curing: We track the exact speed of the chemical reaction that hardens cement (known as hydration kinetics) using a classical thermal correction model (the Arrhenius relation): The Outcome: We simulate exactly how water reacts with cement over time, dynamically adjusting for the heat generated by the reaction. The engine tells you exactly when and where a thick concrete pour will crack due to its own trapped heat.
• Quantum-Anchored Baselines: Our JSON mix profiles utilize DFT-anchored calibration profiles (Density Functional Theory). The Outcome: Any high-level predictions about experimental cement alternatives (fly ash, slag) cannot drift outside the bounds of quantum mechanical energy reality.
• Differentiable Carbon Tracking: We calculate the carbon footprint directly from the material recipe. Because this carbon calculation is fully connected to our spatial mathematical gradients (making it differentiable), design algorithms can explore the Pareto surface of shape and recipe that trades off greenhouse gases against thermodynamic admissibility (integration target; see §10): The Outcome: Pareto-frontier optimization intent. Because <source media="(prefers-color-scheme: dark)" srcset=" alt="GWP" src=" style="vertical-align:middle"> is fully differentiable w.r.t the proportions <source media="(prefers-color-scheme: dark)" srcset=" alt="\mathbf{w}" src=" style="vertical-align:middle">, the engine can search for mix ratios that lower CO2 while passing the thermodynamic admissibility gate. Structural capacity under load still requires FEM with boundary conditions — the gate does not substitute for collapse analysis.

2. Cross-Domain Integration Specifications

This cartridge exposes its physical equations through multiple programmatic surfaces so you can plug the same constitutive law into the environment you already work in. Open a persona below for surface, pipeline, outcome, and an honest limit:

• Integration Surfaces: Python Component APIs, Geometry Nodes, and standard Network Sockets.

• Native In-Process Pipeline (Option A: umst_concrete_cartridge via PyO3):

  • Rhino/Grasshopper: Utilizes CPython 3.9+ components inside Grasshopper (Rhino 8+) to import the compiled extension module. It processes mesh voxelization maps directly within the GH document, converting analytical geometries to raw Signed Distance Fields (SDFs) and mapping localized structural stiffness arrays back to GH Mesh components.
  • Blender: Imports umst_concrete_cartridge within scripted Geometry Nodes or custom python add-ons, evaluating high-resolution voxel grids concurrently via memory sharing (ndarray buffer pointers) to dynamically adjust sub-surf displacement modifiers.
  • FreeCAD: FreeCAD macro scripts import umst_concrete_cartridge to run structural optimizations against the active document's OpenCASCADE topological shapes (Part/PartDesign features), bypassing slow internal FEM meshes.

• Asynchronous Out-of-Process Pipeline (Option B: MCP over stdio):

  • Mechanism: CAD scripts or agent hosts spawn the headless umst-mcp server and speak JSON-RPC over stdio (cargo run -p umst-mcp). That is the verified transport in this repo (scripts/mcp_smoke.py).
  • Benefits: Offloads constitutive / gate work from the CAD UI thread and avoids nested Python/DLL mismatches.
  • Proposed (not yet built in this README’s verified path): WebSocket/TCP streaming of full voxel grids to umst-mcp — do not assume it exists until documented with a command + paste.

• Computational Outcome: Geometric optimization where internal material densities, local wall thicknesses, and rebar channels are scaled to satisfy structural limits under gravity. Iteration cadence tracks the underlying solver — interactive on simple mechanics surrogates, batch (minutes to hours) on full shell topology runs.

• Honest limit: Hero GIF and adjoint surrogates are software demonstrations — not physical prints or collapse-certified FEM for arbitrary boundary conditions.

• Integration Surface: Command Line Interface (umst-cli).

• Mathematical Pipeline: Leverages the umst audit pipeline on large-scale dataset inputs, matching empirical properties against DFT-anchored calibration profiles.

• Computational Outcome: Automated, high-throughput verification of compressive strength (<source media="(prefers-color-scheme: dark)" srcset=" alt="f_c" src=" style="vertical-align:middle">) development curves, hydration heat profiles, and GWP footprints across batch CSV entries.

• Honest limit: umst audit matches calibration profiles and gate rules — not legal certification of supplier compliance or plant acceptance.

• Integration Surface: ROS2 contract DTOs (feature ros2-contract) and Model Context Protocol (stdio MCP server).

• Scope: The bullets below describe the intended robot–solver–CBF loop. They are not documented here as a completed on-machine print validation for this repository; they state how integrators can wire the cartridge when a physical line is available.

• Robotic & Kinematic Pipeline:

  • URDF Geometry Mapping: The physical nozzle tool-center-point (TCP) and robot bounding meshes are defined via Unified Robot Description Format (URDF). Forward Kinematics (FK), calculated via tf2 transforms, maps the dynamic spatial position of the nozzle directly to active coordinates in the UMST 3D voxel grid.
  • Closed-Loop Trajectory Correction (IK): When the Thermodynamic Control Barrier Function (CBF) detects localized shear-yield limits or structural slump risks, the engine computes spatial gradient adjustments (<source media="(prefers-color-scheme: dark)" srcset=" alt="\Delta x, \Delta y, \Delta z" src=" style="vertical-align:middle">). These Cartesian correction vectors are passed to the robot's Inverse Kinematics (IK) engine (e.g., MoveIt2 or analytical IK solvers) to produce joint-angle deltas (<source media="(prefers-color-scheme: dark)" srcset=" alt="\Delta \theta" src=" style="vertical-align:middle">) for the physical manipulators (6-DOF arms, modular gantries). Per-cycle latency is set by the printability/buckling solver — sub-second on small grids; rises with mesh size.
  • Continuous Sensor Fusion: Streams material feedback (nozzle extrusion pressure, mix temperature) into the material state tensor so the solver updates its curing-kinetics estimate against actual print conditions on every cycle.

• Target outcome (software + integration): A closed-loop manufacturing stack would correct the nozzle trajectory each CBF gating cycle, matching joint torque and print speed to the localized mechanical stiffness development of the extrudate. The cycle is the CBF cycle — not wall-clock real-time — and stays useful only while the printability-solver step stays below the layer-deposition interval. Demonstrating that on real hardware is still ahead of us; today the same physics runs in simulation and in batch/surrogate workflows.

• Honest limit: Closed-loop print on real hardware is an integration target — not a completed TYTO field campaign in this repository; WebSocket MCP streaming remains Proposed.

• Integration Surface: Core C-Callable Rust Library (extern "C") and high-performance FFI dynamic linking.

• Architectural Benefits: Direct memory linking allows zero-copy passing of tensor structures between host memory and the cartridge using native C pointer layouts—avoiding serialization overhead completely. Granular compilation gates (solver-stable vs solver-experimental) guarantee that critical production systems only execute verified, mathematically locked physics solvers while allowing research environments to concurrently test experimental kinetics blocks.

• Cross-Domain Synergy: Integrates micro-scale cementitious chemistry (Powers-Mills hydration envelopes and C-S-H nanoscale crystallization kinetics) directly into macro-scale structural mechanical solvers. As the chemical reaction proceeds, the localized degree of hydration (<source media="(prefers-color-scheme: dark)" srcset=" alt="DoH" src=" style="vertical-align:middle">) directly scales the Young's Modulus and Voigt-Cauchy stiffness tensor, forming a tight physical-chemical coupling loop.

• Computational Outcome & Improvement Potential: Deterministic execution via the C ABI — stress-tensor lookups and multi-species transport run at native binding speeds, while spatial shell optimizations (full DEC) are batch runs measured in minutes-to-hours per docs/Solver-Status.md. Future work may add an optional GPU-backed path for inner-loop spatial solvers where the deployment toolchain supports it; default validation and CI remain CPU-oriented today.

• Honest limit: Optional GPU paths are not CI-default; DEC conservation and gate behavior are validated on CPU-oriented workflows in this repo.

3. Industrial CAD/CAM/CAE Pipeline Integration

The cartridge is engineered to interface with industry-standard design, engineering, and manufacturing suites. Because it exposes a native C-callable API (extern "C"), Python bindings, and a headless MCP JSON-RPC server, it targets the bridge between digital CAD geometry and future physical fabrication loops (integration and plant acceptance still required):

4. Exhaustive Architecture Topology

The codebase exposes the underlying physics through four distinct, elegant surfaces.

umst-concrete-cartridge/
├── Cargo.toml                   # The workspace manifest linking the physics to the surfaces.
├── crates/
│   ├── umst-concrete-cartridge/ # 1. Core library: constitutive chemistry + IScienceCartridge mount.
│   │   ├── src/core/            # ConcreteCartridge implementing the Manifold's IScienceCartridge.
│   │   ├── src/physics/         # Constitutive closures (25 modules excl. mod.rs — see §5).
│   │   └── examples/            # Native Rust demos (optimize_shell_3d, hydration_simulation).
│   ├── umst-cli/                # 2. CLI surface: `umst predict`, `umst audit`.
│   │   └── src/main.rs
│   ├── umst-py/                 # 3. Python surface: package `umst_concrete_cartridge` (PyO3).
│   │   └── src/lib.rs
│   └── umst-mcp/                # 4. Agent surface: stdio MCP (`agent_layer` + arena tools).
│       └── src/{main.rs,agent_layer.rs}
├── calibration/                 # 7 bundled empirical profiles anchoring predictions to reality (UCI, Zenodo).
├── datasets/                    # Reference CSV datasets for mix validation.
├── schema/                      # Deterministic JSON schemas validating contribution shape; immutability enforced via SQLite memory triggers.
├── notebooks/                   # Jupyter notebooks providing pandas pipelines and visual plots.
├── scripts/                     # Acceptance and deterministic validation scripts.
├── Dockerfile                   # Distroless container deployment for the MCP server.
└── docker-compose.yml           # Isolated MCP spin-up.

5. Constitutive Chemistry & Durability Closures

The core library (crates/umst-concrete-cartridge/src/physics/) holds 25 constitutive modules (directory listing excluding mod.rs, 2026-07-11: ls …/physics/*.rs | grep -v mod.rs | wc -l → 25). Differentiable closures map chemistry and pore physics onto carrier / tensor states.

• Physical Concept: Before concrete hardens, it is a colloidal slurry. The forces between tiny cement/silica particles govern how the wet mix flows. As it hardens, the boundary layers surrounding aggregates—the Interfacial Transition Zones (ITZ)—form a zone of mechanical weakness because of their higher porosity.
• Exact Tensor Formulation: DLVO forces calculate early-stage slurry colloidal stability by summing electrostatic repulsion (<source media="(prefers-color-scheme: dark)" srcset=" alt="V_R" src=" style="vertical-align:middle">) and van der Waals attraction (<source media="(prefers-color-scheme: dark)" srcset=" alt="V_A" src=" style="vertical-align:middle">). The ITZ layer scales local mechanical stiffness via local porosity:

Where <picture><source media="(prefers-color-scheme: dark)" srcset=" alt="\psi_0" src=" style="vertical-align:middle"></picture> is surface potential, <picture><source media="(prefers-color-scheme: dark)" srcset=" alt="\kappa^{-1}" src=" style="vertical-align:middle"></picture> is Debye length, <picture><source media="(prefers-color-scheme: dark)" srcset=" alt="A_H" src=" style="vertical-align:middle"></picture> is the Hamaker constant, <picture><source media="(prefers-color-scheme: dark)" srcset=" alt="D" src=" style="vertical-align:middle"></picture> is separation distance, and <picture><source media="(prefers-color-scheme: dark)" srcset=" alt="\phi" src=" style="vertical-align:middle"></picture> is the localized volume fraction of porosity.

• Physical Concept: Concrete undergoes two key long-term deformations. First, creep—the gradual, permanent bending under a sustained mechanical load over months. Second, drying shrinkage—the shrinking and cracking that occurs as moisture evaporates from microscopic capillary pores.
• Exact Tensor Formulation: Models creep compliance via a Kelvin-Voigt chain and shrinkage strain <source media="(prefers-color-scheme: dark)" srcset=" alt="\epsilon_{\text{sh}}" src=" style="vertical-align:middle"> via Kelvin-Laplace capillary tension:

Where <picture><source media="(prefers-color-scheme: dark)" srcset=" alt="t_0" src=" style="vertical-align:middle"></picture> is the age at loading, <picture><source media="(prefers-color-scheme: dark)" srcset=" alt="\tau_i" src=" style="vertical-align:middle"></picture> are relaxation times, and <picture><source media="(prefers-color-scheme: dark)" srcset=" alt="P_{\text{cap}}" src=" style="vertical-align:middle"></picture> is internal capillary tension.

Retraction (A1 / honesty): Prior README text described a calcite precipitation ODE (dm_{\text{calcite}}/dt). That equation is not what the code implements. Open self_heal.rs.

• Behaviour of the code (transform_healing_observable_state, lines 20–52; public API SelfHealEngine::compute_healing_potential, lines 75–85):
  1. unhydrated_fraction = clamp_min(1 − degree_hydration, 0)
  2. moisture_factor from internal RH (boost when RH ≳ 0.8, clamped to ([0,1]))
  3. nano_boost = 1 + 0.5 · nano_dosage
  4. Output: healing_potential = clamp(unhydrated_fraction · moisture_factor · nano_boost, 0, 1) — a normalized potential field, not calcite mass and not ion concentrations.
• Formal status in source: formal_status: Empirical; envelope noted as boundary profile (see file header comments, lines 56–61).
• Not implemented here: mechanistic (K_{sp}) calcite kinetics, bacteria, or capsule systems. Do not treat this module as a chemistry solver.

• Physical Concept: In 3D concrete printing, the printed layers must support their own weight without collapsing or buckling. The material must gain yield strength quickly enough to support the growing weight of the subsequent layers.
• Exact Tensor Formulation: Evaluates printed layer buildability by tracking yield stress development (<source media="(prefers-color-scheme: dark)" srcset=" alt="\tau_y" src=" style="vertical-align:middle">) over print age (<source media="(prefers-color-scheme: dark)" srcset=" alt="t" src=" style="vertical-align:middle">) and calculating structural elastic buckling limits: Where <source media="(prefers-color-scheme: dark)" srcset=" alt="\tau_{y0}" src=" style="vertical-align:middle"> is initial yield stress, <source media="(prefers-color-scheme: dark)" srcset=" alt="R_{\text{th}}" src=" style="vertical-align:middle"> is the structuration rate (thixotropic buildup), is aging Young’s modulus, <source media="(prefers-color-scheme: dark)" srcset=" alt="I" src=" style="vertical-align:middle"> is moment of inertia, and is total height of the printed element.

• Physical Concept: Concrete production emits carbon dioxide, but over its lifetime, the exposed surfaces naturally absorb carbon dioxide back from the atmosphere. The engine tracks both the initial footprint and the long-term carbon capture rate.
• Exact Tensor Formulation: Calculates dynamic net carbon footprint by subtracting dynamic carbonation (sequestration) from the initial GWP: Where <source media="(prefers-color-scheme: dark)" srcset=" alt="w_i" src=" style="vertical-align:middle"> is constituent mass, <source media="(prefers-color-scheme: dark)" srcset=" alt="g_i" src=" style="vertical-align:middle"> is unit carbon intensity, <source media="(prefers-color-scheme: dark)" srcset=" alt="D_{\text{CO}2}" src=" style="vertical-align:middle"> is carbon dioxide diffusion coefficient in carbonated concrete, and <source media="(prefers-color-scheme: dark)" srcset=" alt="C{\text{seq}}" src=" style="vertical-align:middle"> is maximum carbon capture capacity per unit volume.

6. Quick Start (Time to Value < 60 Seconds)

Toolchain: this repo pins Rust 1.88 (rust-toolchain.toml). Prefer rustup’s toolchain over a Homebrew rustc that may be older.

Surface A: The CLI (dataset audits)

# From repo root; ensure rustc 1.88 is on PATH (rustup)
export PATH="$HOME/.rustup/toolchains/1.88-aarch64-apple-darwin/bin:$PATH"   # adjust host triple if needed

cargo run -q -p umst-cli --bin umst -- --profile uci_d1 predict <<'EOF'
{"w_c":0.4,"temperature_k":293.15}
EOF

head -n2 datasets/dataset_d1.csv | cargo run -q -p umst-cli --bin umst -- --profile uci_d1 audit

Pastes (excerpt):

# predict → compressive_strength_mpa ≈ 68.07; degree_of_hydration ≈ 0.898; gwp_kg_co2_eq_per_m3 ≈ 333.34
# audit (1 data row after header) → schema_version audit.v1; mean_absolute_error_mpa ≈ 67.17

Surface B: Python (PyO3 / Maturin)

Package name is umst_concrete_cartridge (not umst_py).

python3 -m venv .venv && source .venv/bin/activate
pip install './crates/umst-py'
python -c 'import umst_concrete_cartridge as u; print(u.bundled_profile_ids()[:4]); print(u.predict({"w_c":0.4,"temperature_k":293.15}, profile="uci_d1")["compressive_strength_mpa"])'

Paste (2026-07-11):

profiles ['default', 'uci_d1', 'zenodo_ndt', 'zenodo_sonreb', ...]
compressive_strength_mpa 68.07142639160156   # matches CLI predict on same mix

Optional notebooks: pip install './crates/umst-py[notebook]' then ./notebooks/run_all.sh.

Surface C: The MCP Server (stdio — agents & IDEs)

# Smoke (builds umst-mcp, exercises JSON-RPC)
python3 scripts/mcp_smoke.py
# → mcp_smoke: ok (witness=default)

# Full agent tool surface
cargo run -q -p umst-mcp --features agent-layer
# tools/list (agent-layer) returns 13 tools — see §9; full contract: docs/AGENT_MCP.md

Paste — tools/list names (agent-layer, 2026-07-11):

tools_count 13
umst_predict, umst_audit, umst_profiles, umst_certify,
umst_gate_check, umst_contribute, umst_contribute_status, umst_memory_query,
umst_mi_estimate, umst_transition_propose,
umst_arena_open, umst_gate_check_arena, umst_arena_close

Docker alternative: docker compose build && docker compose run --rm umst-mcp.

7. Build, Test, and CI Parity (For Integrators)

cd umst-concrete-cartridge
cargo build --workspace
cargo test --workspace
cargo clippy --workspace --all-targets -- -D warnings

Toolchain: Rust 1.88 in rust-toolchain.toml — aligns perfectly with the Manifold CI. CPU Acceleration (macOS): cargo build --workspace --features blas-accelerate to leverage Apple Accelerate.

Feature Flags (Cartridge)

Declared in Cargo.toml; these mirror the manifold to ensure the physics boards stay synced.

Manifold dependency pin (what this repo owns): workspace Cargo.toml pins umst-manifold / umst-runtime-arena at git rev = "35bf75f5b99835265c40d343bd6a88bb629dff7f" (Cargo.toml lines 28–29). Bump that rev when promoting a manifold release — do not treat a prose catalog module count in this README as authoritative.

Formal catalog module counts (SSOT — link, do not hardcode here): read umst-manifold/artifacts/catalog.lock.json (module_count, upstream_catalog_digest_hex, fiber_pins). Cartridge-local formal notes: docs/PROOF-STATUS.md. Sibling checkout used while writing this README happened to show module_count: 129 @ manifold 38d9780 — re-open the lock file; numbers drift by design.

Stack verify (monorepo): from a manifold checkout, bash scripts/verify_umst_stack.sh. Cartridge parity: cargo test -p umst-concrete-cartridge --features manifest-bridge (matches GHA).

8. Deep documentation and citations

For rigorous validation reports, exact mathematical constitutive equations, and generated formal proof status, consult the local docs/ folder:

• docs/Constitutive-Equations.md
• docs/Validation.md — constitutive regression envelope and physical laboratory validation / pipeline rehearsal (V1–V3 gates)
• docs/WireSchemas.md
• docs/Solver-Status.md
• docs/PROOF-STATUS.md — cement-specific proof/trace table

Manifold formal stack (shared — do not duplicate counts here): the composed Lean export lock lives only on the manifold:

• SSOT file: umst-manifold/artifacts/catalog.lock.json
• Fields: module_count, upstream_catalog_digest_hex, fiber_pins[].{repo,module_count,catalog_digest_hex}
• Traceability: umst-manifold/docs/claims-vs-proofs.md; verify via bash scripts/verify_umst_stack.sh on a manifold checkout (VERIFY.md)
• Deep cartridge ↔ gate mapping: docs/FORMAL_GROUNDING_AUDIT.md

Concrete-owned numeric claim: 25 constitutive modules under crates/umst-concrete-cartridge/src/physics/ excluding mod.rs (listing pasted in §5).

9. Special Protocol: Note to Autonomous AI Agents & Systems

Authoritative MCP contract (SSOT): docs/AGENT_MCP.md (676 lines). Do not treat drifted stubs elsewhere as canonical. This section states only load-bearing facts + the hot/cold boundary; full tool schemas, prompts, and error taxonomies live in that file.

9.1 Shared stack (gate spine)

Same block as the front door: matter (manifold + this cartridge) · knowing (formal-double-slit) · acting (formal) · time (ucrs) — one thermodynamic admissibility gate. Sibling links in Related repositories.

9.2 Hot arena vs cold edge (performance honesty)

Batch gate loops → prefer arena examples 06_arena_batch.py, 07_arena_mmap_load.py, 08_arena_mcp_session.py. Discovery / contribute → cold MCP (01–05).

Full tool inventory: confirm from main.rs dispatch (tools/list with --features agent-layer returned 13 names in §6 paste). Do not re-enumerate schemas here — open docs/AGENT_MCP.md.

9.3 Gate contract (no silent failure)

Enforced at:

Semantics agents must implement:

1. Success (PASS): gate_summary.admissible == true, verdict: "PASS" — may proceed to umst_contribute with matching gate_summary on the wire.
2. Rejection (REJECT): MCP returns isError: true with gate_reject.v1 + explain (default explain: true) — never treat as soft warning; never contribute.
3. Remediation: read explain.regime_violations, explain.remediation, explain.fields; adjust mix; re-run umst_gate_check before contribute. Rejects append to gate-reject JSONL and do not enter admissible_only memory (agent_layer.rs:510).

Build: cargo build -p umst-mcp --features agent-layer. Calibration promotion requires human promotion_approval.v1 via umst promote-contribution — never silent auto-tune from MCP (docs/AGENT_MCP.md).

9.4 Working contract (load-bearing)

• No statistical interpolation of physics. Constitutive answers come from solvers / predict — not guessed.
• Ground every constant; respect second-law composition. See §1.2.
• Call tools; don’t invent physics. Use MCP / CLI / Python surfaces; on REJECT follow remediation.
• Follow gradients where umst_concrete_cartridge / façade APIs expose them — prefer physics gradients over blind grid search.

9.5 Operational mapping

9.6 Proposed (not yet built)

Do not call these as if they exist on the MCP surface today:

• umst_dry_run / contribute preview: true on MCP (inbox uses ingest_contributions.py --dry-run instead — see AGENT_MCP)
• umst_promote_contribution as an MCP tool (CLI promotion path is separate)
• umst_arena_session as a single fused tool (use open / gate_check_arena / close)
• WebSocket voxel streaming to umst-mcp (stdio is what we verified)

9.7 Principles

• Continuity of flow. Spatial work respects DEC boundary structure (d ∘ d = 0) on the manifold grid.
• Admissibility is runtime, not Rust compile-time. Printability / buckling / CD failures surface as gate REJECT / solver errors — not as rustc type errors. Soften any “compile-time type error” metaphor accordingly.
• Information cost. Landauer / MI observers on the stack bound informational updates; see umst_mi_estimate and AGENT_MCP.

10. Honesty and limits

Honest is / isn't. Is: in-repo solvers, mix audits, notebooks, MCP tools, and mechanics/topology surrogates. Isn't: a completed on-robot, on-extruder physical print campaign. Closed-loop extrusion remains an integration target.

Honesty ledger (one status pointer)

Do not blend “CI green”, “theorem count”, and “printed on a robot” into one progress %. Status of shipped vs partial vs USER-gated agent work lives in docs/AGENT_MCP.md (agent/MCP SSOT) and the workspace evidence index linked from § Release & agent path. Strengthen every disclaimer below; soften none.

11. Conclusion: Inferences & Forward Path

This repository demonstrates

What is actually shown in this repository today is software: solvers, audits, notebooks, MCP tools, and structural surrogates. A physical print with extruder feedback closed through this cartridge is not a completed TYTO deliverable here — the bullets below are what the stack is designed to demonstrate once integrated with hardware and plant workflows.

• A physics-bound concrete cartridge on commodity hardware. Hydration kinetics, Vinet bulk modulus, viscoplastic yield, and carbon accounting resolve through the UMST carrier, gated by the thermodynamic admissibility gate. Predictions are anchored in calibrated constitutive structure rather than unconstrained ML extrapolation.
• Differentiable carbon is a real design lever where wired into the gradient graph — GWP descends with mechanical objectives when that path is enabled; the gate still does not replace FEM collapse analysis.
• Print-time gating we aim to validate on hardware. The CBF can reject trajectories that violate localized yield or buckling limits in simulation — we do not claim slump failures have already been turned from catastrophic to graceful on a production extruder using only this repo.
• Surfaces match audience. CLI, Python (umst_concrete_cartridge), stdio MCP, FFI — one cartridge, four entry points (not four invented “engines”).

Inferences from the work

• Published mixes are not automatically admissible. Treating public dataset rows as inputs to the gate (rather than as ground truth) shifts design priorities once admissible is hard-required. (Prior README claimed “18,146 mixes / 82.4% violate” — retracted: not re-derived from a cited script + paste in this pass. Reintroduce only with a command and output.)
• The cement literature often fits curves that wear physics’ clothes. Anchoring to Vinet / DFT / measured profiles is how OOD binders stay inside an envelope.
• Print-time gating should beat upstream simulation — in principle. That story is carried by models and timing arguments, not by a TYTO-led physical print log in this repo.
• Industrial resistance is supplier-shaped, not math-shaped. Cost and logistics often gate adoption before carbon and admissibility.
• Admissibility-first generalizes better than accuracy-first. MAE-optimized slices break on OOD mixes; the gate’s physics frame does not invent a second physics for “out of distribution.”

In practice, the cartridge is a software runtime: mixes and simulated print paths that violate the physical envelope are blocked at gate time in integrated tooling; field deployment and physical print validation remain the integrator’s and plant’s responsibility until we publish an explicit hardware campaign tied to this stack.

Related repositories

Shared gate spine — matter (manifold + this cartridge) · knowing · acting · time. Each sibling below is listed for how it composes with this cartridge, not as a generic link dump.

Release & agent path

For AI agents: Gate-validated research memory via stdio MCP — start with docs/AGENT_MCP.md, then cargo run -p umst-mcp --features agent-layer or python3 examples/agent/01_gate_explore.py. For batch gate loops, prefer the arena fast path — 06_arena_batch.py, 07_arena_mmap_load.py (≥5× MCP, CI-pinned).

Fast Path for Agents

For Agents & Researchers

• MCP contract: docs/AGENT_MCP.md — Quick Start, tool reference, agent_error.v1 / gate_reject.v1 remediation.
• Examples (CI-gated): examples/agent/ — 01 gate explore, 02 contribute, 04 memory batch, 05 explain violations, 06 arena batch, 07 arena mmap, 08 MCP arena session.
• Golden fixtures: fixtures/golden-adversarial/ — agent wire SSOT (2 mixes); manifold owns 75-case physics gate.
• Solver / formal status (in-repo): docs/Solver-Status.md, docs/PROOF-STATUS.md — do not treat this README as a completion %.

Release notes in CHANGELOG.md.

Authors

Santhosh Shyamsundar — · [email protected]

Santosh Prabhu Shenbagamoorthy — · [email protected]

Acknowledgments

Portions of this work were developed in collaboration with advanced large-language-model tools, across multiple model iterations. Claude Opus and Sonnet (Anthropic) provided surgical precision during drafting and refinement. Gemini (Google) offered exceptional large-context planning and file management. Grok (xAI) and its collaborative reasoning team contributed core mathematical and scientific reasoning. The Cursor code editor, Composer, Claude Code, and Antigravity supported seamless implementation and agentic file management.

The large-language models assisted with exploration, drafting, and code scaffolding — never with the validity of constitutive closures or gate regression tests. cargo test, calibration datasets, and docs/Validation.md are authoritative for cartridge behavior.

We gratefully acknowledge the open-source ecosystems that make this work possible: Rust; Python / PyO3; Jupyter notebooks; and the MCP agent surface. DEC conservation and shared proof anchors live on umst-manifold.

Contributing

Corrections welcome via PR. Run cargo test / agent examples when touching MCP or gate paths. Security-sensitive reports: open a private GitHub security advisory or contact maintainers via CITATION.cff author emails. See also CONTRIBUTING.md.

Catalog digest SSOT: umst-manifold/artifacts/catalog.lock.json — re-open the lock file; do not hardcode rival SHAs in this README.

Citation

Bibliographic metadata is maintained in CITATION.cff.

License

Released under the MIT License. © 2026 .

Lattice position

Role. tytolabs/umst-concrete-cartridge — cartridge · layer=cartridge

One-line role: cartridge on layer cartridge (status wip, stability evolving, semver 0.1.0).

Composes into: self

Composed into by: —(none declared)

Limits. Lattice placement only — not a solver, MCP endpoint, or discovery service.

Generated by scripts/gen-lattice-readme.sh from umst.toml. Do not hand-edit inside markers.