Agentic Digital Twins as Code
JMMonte/agentic-digital-twin
Gêmeos digitais de engenharia definidos em código com IA e simulação integrada
Ver no GitHubAgent Claude que constrói gêmeos digitais de engenharia como código, integrando geometria CAD definida em código com simulações de física, CFD e FEA, verificação scored e visualização em Rerun. Pronto para hardware-in-the-loop com convenções de best-practice para projetos de modelagem e simulação.
Instalação
npx convez-ai JMMonte/agentic-digital-twin1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Desenvolvimento de protótipos digitais com validação automática
- Simulação de CFD/FEA acoplada a geometria parametrizada
- Fusão de dados de telemetria para gêmeos digitais em tempo real
- Auditoria e verificação scored de requisitos de engenharia
Veredito

Ferramenta robusta e opinada para equipes de engenharia que dominam simulação numérica e querem elevar a prática com automação por agentes IA. Excelente para monorepos de M&S com requisitos de auditoria rigorosa, mas curva de aprendizado alta e ecossistema dependente (FreeCAD, OpenFOAM, CalculiX).
README
A tradução para o português deste README ainda está na fila.
Agentic Digital Twins, as Code

A Claude Code plugin for building engineering digital twins as code with AI agents — code-defined geometry + digital twin simulation (physics, CFD, FEA) + scored verification, with rerun for visualization and data fusion toward live, closed-loop twins. It packages the conventions and hard-won gotchas from a working modeling-and-simulation monorepo (lunar lander, aircraft, a real-aircraft digital twin), so a new hardware / CAD / sim project starts at best-practice on day one and the lessons keep accruing as you learn. Hardware-in-the-loop ready.
It is a living artifact: the guardrails checklist and project AGENTS.md are structured for new lessons, gotchas, and skills to append cleanly.
What "digital twins as code" means here
- Spec/geometry is code. One source-of-truth
design.json, mirrored into the build source (e.g.Design.cs). Published/measured values tagged[PUB]; everything else derived and traceable. - Materials are cited, never hallucinated. A
materials.jsonsource of truth holds every property with a citation (MMPDS / CMH-17 / ASM / datasheet); audits read from it — there's no free allowables API, so the discipline is the defense. Composites cite the specific prepreg + fiber-volume-fraction + layup; fluids come from CoolProp. (add-materialskill, GUARDRAILS §8.) - Every requirement gets an executable, scored audit. PASS/WARN/FAIL, exit 1 on FAIL, a markdown report. Audits read the build's exported JSON artifacts — they never duplicate a geometry constant.
- uv single-file PEP 723 scripts (
uv run script.py), not venvs. numpy / scipy / trimesh are the workhorses. - Visualization is rerun — one
.rrdper concern, milestones archived, every mesh getsvertex_normals. - A verification ladder for assemblies (components → intersections → contact graph → single-island check) with joints modeled as components.
- FEA is tiered — analytic audit checks → in-house numpy beam FEA →
gmsh + CalculiX (
ccx) for continuum parts, each tier validated against the one below (a*BUCKLEeigenvalue must match the analytic EulerP_cr). - Design iteration is a scored tradeoff study with sensitivity — pick the robust option, not the one-weighting winner; only the winner gets a full build.
- Manufacturability is an automation⇄agent blend — the agent authors judgment, automation scores it, loop until it packs.
- Guardrails are gold. Silent-failure traps (a wrong boolean still
passes watertight;
np.interpneeds ascendingxp; voxel kernels fail silently; CFDFLUID_MODELdefaults) live in an append-only checklist. - Two doors in. Author geometry as code (
design.json→ build), or bring an existing CAD file (import-cad: STEP/STL → the same audits, FEA, CFD, and viz). Either way the scored-audit + cited-materials discipline applies.
What's in the plugin
agentic-digital-twin/
├── .claude-plugin/
│ ├── plugin.json # manifest (name, version, description, author, keywords)
│ └── marketplace.json # single-plugin marketplace catalog (for distribution)
├── GUARDRAILS.md # the LIVING gotcha checklist — append new lessons here
├── README.md
├── agents/
│ └── hardware-as-code-engineer.md # the methodology subagent persona
└── skills/
├── scaffold-hw-project/ # stand up a new project at best-practice
│ ├── SKILL.md
│ └── templates/ # runnable skeletons copied into the new project:
│ ├── design.json # source-of-truth design of record
│ ├── Design.cs # build-source mirror stub
│ ├── audit.py # scored audit harness
│ ├── viz.py # rerun visualization harness
│ ├── tradeoff.py # scored study + sensitivity + tiled compare
│ ├── fea_continuum.py # tier-3 continuum FEA (gmsh + CalculiX), anchor-gated
│ ├── judgment.json # manufacturability AGENT layer
│ ├── packaging_solve.py # manufacturability AUTOMATION layer
│ └── AGENTS.md # repository map + workflow + guardrails
├── add-scored-audit/ # add one PASS/WARN/FAIL check the right way
├── run-tradeoff-study/ # placement-level study + sensitivity + side-by-side
├── continuum-fea/ # tier-3 stress/buckling: gmsh + CalculiX, validated vs analytic
├── manufacturability-loop/# the automation⇄agent packaging loop
└── guardrails-check/ # apply the checklist + append new lessons
Skills
| Skill | What it does |
|---|---|
scaffold-hw-project | Creates a new project with the design-of-record, a scored-audit harness, a rerun viz harness, a tradeoff-study template, the manufacturability judgment+solver pair, and an AGENTS.md + GUARDRAILS.md — all runnable skeletons, not prose. |
add-scored-audit | Adds a single executable requirement check (reads exported JSON, asserts an expected value, exits 1 on FAIL) and rejects the anti-patterns (duplicated constants, >0 instead of expected, WARN hiding a FAIL). |
run-tradeoff-study | Resolves a design fork with a placement-level scored study, a sensitivity sweep across weight schemes, and a tiled side-by-side rerun comparison; only the robust winner earns a full build. |
continuum-fea | Runs the tier-3 continuum FEA (brackets, panels, shells, lugs) with gmsh + CalculiX (ccx): tet-mesh → Abaqus .inp → solve headless → parse → VALIDATE against the analytic tier (*BUCKLE P_cr / cantilever deflection) → mesh convergence → stress field to rerun. Refuses to trust a single mesh. |
manufacturability-loop | Drives the agent-authors-judgment / automation-scores-it packaging loop (containment, collisions, mass closure, CG, retrieval) until it packs. |
guardrails-check | Sweeps the silent-failure checklist before you trust a result, and is the entry point for appending a new lesson with its regression guard. |
Agent
hardware-as-code-engineer — a subagent persona embodying the whole
methodology and the guardrails, which distrusts any number not cross-checked
against an anchor. Appears as agentic-digital-twin:hardware-as-code-engineer.
Install
This plugin is its own repo (JMMonte/agentic-digital-twin). Its
.claude-plugin/ directory holds BOTH a plugin.json (so the directory is
a valid plugin) and a marketplace.json (so the same directory doubles as a
single-plugin marketplace via "source": "./").
Option A — from GitHub (recommended)
/plugin marketplace add JMMonte/agentic-digital-twin
/plugin install agentic-digital-twin@agentic-digital-twin-marketplace
Option B — from a local clone
git clone https://github.com/JMMonte/agentic-digital-twin
/plugin marketplace add ./agentic-digital-twin # the dir doubles as the marketplace root
/plugin install agentic-digital-twin@agentic-digital-twin-marketplace
# or, for one session without installing:
claude --plugin-dir ./agentic-digital-twin
Validate at any time:
claude plugin validate ./agentic-digital-twin --strict
Use
/agentic-digital-twin:scaffold-hw-project # start a new project
/agentic-digital-twin:add-scored-audit # add a requirement check
/agentic-digital-twin:run-tradeoff-study # resolve a design fork
/agentic-digital-twin:continuum-fea # tier-3 stress/buckling (gmsh + CalculiX)
/agentic-digital-twin:manufacturability-loop # pack the internals
/agentic-digital-twin:guardrails-check # sweep the gotchas / log a lesson
Or just ask, and Claude invokes the right skill / the
hardware-as-code-engineer agent based on the task.
How to EXTEND it (this is the point — it's a living artifact)
-
A new gotcha / lesson → append to
GUARDRAILS.md. Newest first, dated, with symptom + cause/fix + the regression guard you added. Reusable classes go in sections 1-6; project-specific in section 7. Theguardrails-checkskill walks you through it. The scaffolder copies this file into every new project, so improvements propagate to new projects and each project also grows its own local lessons. -
A new skill → add
skills/<name>/SKILL.mdwith YAML frontmatter (name+ a trigger-richdescription). It is auto-discovered; bumpversioninplugin.jsonso installed users get it. -
A new template → drop it in
skills/scaffold-hw-project/templates/and add acpline to that skill's procedure so new projects pick it up. -
Refine the agent persona → edit
agents/hardware-as-code-engineer.md. -
Release → bump
versionin BOTHplugin.jsonand themarketplace.jsonentry (plugin.json wins if they differ), and note the change. Without a version bump, installed users keep the cached copy.
Spec sources
Built against the current Claude Code plugin spec:
- Plugins reference —
manifest schema, component layout,
${CLAUDE_PLUGIN_ROOT}, validation. - Plugin marketplaces
—
marketplace.jsonschema,source,strict. - Official plugin directory.
Methodology source: the AGENTS.md files of the lander/, aircraft/, and
seagull/ projects in this monorepo.
Credits
Hero banner rendered with PyVista (assets/hero.py) from real 3D models: