Technology

Built for a line that will not wait for you.

Microsecond physics, millisecond decisions, packages worth thousands of dollars moving past a nozzle. The architecture follows from those constraints, not from a cloud-first habit.

Three-tier architecture diagram: cloud control plane, fab-edge runtime, and the line tier of bonders, molding, inspection and test cells.
Control plane, fab edge, line. Chipira architecture illustration.

First principle

Inference belongs where the package is

Why not the cloudA hybrid-bond alignment correction that arrives after the bond has been made is not a correction. It is a post-mortem.

The decisions that matter in advanced packaging are made in the window between a die being picked and a bond being committed. That window does not accommodate a round trip to a region, a queue and a cold start.

So Chipira runs its perception and control models on fab-edge hardware inside your building — TensorRT-optimised vision through DeepStream and Metropolis for AOI, X-ray, CT and SAM streams, Holoscan for sensor fusion, and an agent runtime on a small on-site Kubernetes footprint.

The control plane still matters — model registry, fleet management, evaluation gates, fine-tuning — but it governs rather than serves. It can be a private VPC. It can be entirely on your premises. The line keeps running when it is unreachable.

Where your data actually sits

The accelerated stack

Physical AI, applied to a back end

Perception

Edge vision at line rate

Jetson Orin and Thor-class edge systems or industrial GPU servers run TensorRT models through DeepStream and Metropolis for AOI, X-ray and CT, SAM, void, warpage, bump, die-crack, delamination and hybrid-bond alignment inspection.

  • Design target: 8–32 feeds per line [ASPIRATIONAL]
  • Design target: 30–120 FPS on AOI streams [ASPIRATIONAL]

Fusion

Time-aligned sensor streams

Holoscan aligns inspection frames with metrology, recipe, force, temperature, pressure, cure and test telemetry so a defect can be attributed to the moment and the setpoint that produced it.

  • Millisecond-to-second alignment [ASPIRATIONAL]
  • Across bonders, molding, inspection and test

Training

Tenant-isolated fine-tuning

DGX and HGX-class training on defect images, CT volumes, SAM maps, AOI images and tool telemetry, producing segmentation, detection, anomaly, time-series and root-cause models scoped to your fab.

  • Design target: monthly tenant fine-tuning [ASPIRATIONAL]
  • Federated aggregation only where contracted

Synthesis

Rare defects you cannot afford to collect

Cosmos and Omniverse Replicator generate calibrated void, warpage, particle, misalignment, die-crack and delamination variants — expanding sparse coverage without exposing process IP or scrapping real packages.

  • Design target: 100k–1M synthetic scenarios per package family [ASPIRATIONAL]
  • Correlated against real data before use

Optimisation

Real solvers, not heuristics

cuOpt solves known-good-die sequencing, cassette routing, tool scheduling, re-inspection routing and ramp DOE — the combinatorial problems a spreadsheet quietly approximates today.

  • Near-real-time rescheduling on disruption
  • Overnight DOE planning for new packages

Simulation

The package-and-line twin

An Omniverse-based twin simulates bonding, stacking and molding, auto-optimising recipe and alignment to hit target warpage, void and yield before the run — and pre-validating every agent move.

  • Thermo-mechanical priors, ML-corrected
  • Every write-back checked before execution

The twin

Hit the spec before the line runs

The twin is not a visualisation. It is a gate. A proposed recipe that does not clear the warpage, void and yield spec in simulation does not reach the tool.

Warpage contour map with a cross-sectional profile comparing as-designed warpage against a twin-optimised recipe.
Modelled peak warpage falling from 142 µm to 58 µm under twin-optimised recipe and alignment. Chipira design illustration; values are modelled, not measured on a customer line.

Stack

What it is made of

Chosen for latency, isolation and the ability to run in a building with no outbound internet.

Fab edge
Rust and C++ runtime on K3s on site, with NVIDIA IGX-class systems; over-the-air updates delivered as signed artifacts on your schedule.
Services
Go and Python FastAPI services with a NestJS control plane; event-driven agent runtime with idempotent steps and human-approval checkpoints.
Data
PostgreSQL with pgvector for defect-image and recipe retrieval, TimescaleDB for bonding, molding and test telemetry, Redis for hot state.
Serving
Triton for multi-model CV and time-series serving, NIM for enterprise inference microservices, NeMo-tuned models for process and root-cause reasoning.
Observability
OpenTelemetry tracing end to end, Grafana and Datadog for operations, Langfuse for agent-level evaluation and trace review.
Delivery
GitHub Actions, Terraform and ArgoCD, with evaluation gates that block a model or prompt change from shipping if it regresses a golden dataset.

The interface

An envelope is a contract

Action envelopes are declared as versioned, reviewable configuration owned by your process engineers — not buried in our code. Chipira cannot act outside one, and changing one is itself an audited action.

Developer documentation

envelopes/hybrid-bond-line4.yaml
# Owned by process integration. Reviewed like a recipe.
envelope: hybrid-bond-line4
tool_class: hybrid_bonding_aligner
autonomy: L2                 # bounded autonomy

bounds:
  placement_offset_um:   { min: -0.35, max: 0.35 }
  bond_force_n:          { min: 12.0,  max: 21.0 }
  stage_temp_c:          { min: 118,   max: 152 }
  theta_deg:             { min: -0.01, max: 0.01 }

rate_limits:
  setpoint_writes_per_hour: 24
  max_step_change_pct:      5

gates:
  # every move is simulated before it is written
  - twin.validate(spec: "warpage<80um, voids=0")
  - grounding.require_citations()
  - accuracy.min_rolling(window: "7d", floor: 0.985)

on_breach: rollback_and_escalate
approvers: [ process_integration, quality ]

Illustrative envelope definition.

Evaluation

How a model earns its way onto a line

Nothing reaches a tool because it looked good in a notebook.

  1. Golden datasets, per package family

    Every model is scored against curated, engineer-labelled sets drawn from your own defect corpus — not a public benchmark that shares nothing with your package.

  2. Continuous evaluation in CI

    Model and prompt changes are gated. A regression on the golden set blocks the release, automatically, before any fab sees it.

  3. Twin correlation

    Synthetic and simulated data are correlated against real outcomes before being trusted for training. Uncorrelated synthetic data is treated as a liability, not an asset.

  4. Shadow before authority

    Even a passing model enters your line in shadow mode and must beat the measured baseline before it is granted advisory status, let alone autonomy.

Show me the evaluation harness and I will tell you whether to trust the model.

Quality and reliability engineerAutomotive-grade packaging

Composite drawn from design-partner and industry conversations. Illustrative, not a customer endorsement.

Design targets

The numbers we are engineering toward

  • <100 ms Inference latency for inspection and alignment decisions that affect routing or review.
  • 8–32 Camera or sensor feeds handled per line by the fab-edge vision runtime.
  • 30–120 Frames per second sustained on AOI streams where the tool supports it.
  • 99.9% Platform uptime target, with fail-safe degradation to existing tool control.

These are engineering design targets [ASPIRATIONAL], not measured production results. Real figures depend on tool class, sensor resolution and line configuration, and are established during shadow-mode deployment.

Technical questions

For the people who will run it

  • A single industrial GPU server or Jetson-class edge system per line is the usual starting point for one wedge workflow, sized against your sensor count and resolution during scoping. Multi-module deployments scale to a small edge fleet.

  • As signed artifacts, on your schedule, through a governed release channel. You can pin a version indefinitely. Nothing auto-updates on a production line without an explicit approval.

  • Yes. The model router is deliberately model-agnostic. If you have an internal defect classifier you trust, it can be registered, evaluated against the same golden sets, and served alongside ours.

  • Time-series telemetry in TimescaleDB, defect imagery and recipe embeddings in PostgreSQL with pgvector, all per-tenant scoped. Retention is configurable and, in an on-premise deployment, entirely yours.

Start narrow, expand relentlessly

Land one workflow. Own the loop.

A Chipira engagement begins with a single wedge workflow, a shadow-mode baseline and one signed success metric. Everything after that is expansion.