
Guest contribution from Vivid3D. The partner link in this article is sponsored.
A robotics team spends three months tuning the threshold that decides whether a warehouse robot treats a shadow on the floor as an obstacle. They ship the model, move on to the next sensor, and six months later a new engineer asks why that threshold is set where it is. Nobody remembers. The Slack thread from the decision is buried under four hundred messages, the Google Doc someone started got abandoned after two entries, and the only record left is the number itself, sitting in a config file with no explanation. This happens constantly on physical AI teams, and it happens for a predictable reason: almost all the engineering effort goes into the data. Teams building physical AI training data pipelines — synthetic scenes, labeled edge cases, multimodal sensor captures — invest heavily in the pipeline itself, and close to nothing in documenting the decisions that shaped it. The data gets versioned. The reasoning behind it doesn't.
Ask a computer vision lead how their training data is generated and they can walk you through the whole stack: which scenarios are synthetic, how ground truth is labeled, which edge cases were added and why. Ask the same person why a specific edge case was prioritized over another, or what tradeoff led to a particular sensor configuration, and the answer is usually a shrug or a search through old messages. That gap matters more on physical AI teams than almost anywhere else in software. A web app's business logic is mostly self-documenting in the code. A robotics stack isn't — the reason a LiDAR threshold is calibrated a certain way, or why an "unsafe scenario" category includes some cases and excludes others, lives in someone's head or in a meeting that happened four months ago. When that person leaves or the team scales, the knowledge doesn't transfer with the code.
Training data pipelines produce artifacts that are easy to version — datasets, model weights, evaluation scores. The harder category is the decisions around them, and most teams have no consistent place to put it.
| Type of knowledge | Where it usually lives (badly) | Where it should live |
|---|---|---|
| Why an edge case was added to the dataset | A closed Slack thread | A linked doc next to the dataset version |
| Sensor calibration rationale | An engineer's personal notes | A shared, searchable record |
| Ground truth labeling disagreements and resolutions | Meeting notes nobody re-reads | A structured decision log |
| Which unsafe scenarios were simulated and which were skipped, and why | Nowhere | A living taxonomy doc |
None of these need a heavyweight process. They need a place that's actually used, which is a different problem than picking a tool.
Robotics and physical AI companies tend to be unusually protective of their internal knowledge, and for good reason. Sensor configurations, safety-case reasoning, and edge-case taxonomies are often as close to the company's real IP as the models themselves. Putting that in a cloud tool where the vendor controls the storage and the export path creates the same kind of dependency risk that these teams already work hard to avoid on the data side — one reason synthetic data generation appeals to them in the first place is that it reduces reliance on third parties for something core to the product. A local-first knowledge base helps address that problem. With a self-hosted setup, the team can keep shared documentation on infrastructure it controls. Local-first editing also lets people work with their notes when a connection is unavailable; teams should still verify the sync, backup, and access controls of their chosen deployment. For a team already thinking carefully about where its training data comes from and who has access to it, applying the same standard to its internal documentation is a small extension of a decision it has already made.
Teams that get this right tend to converge on a similar shape, regardless of which tool they use:
This isn't a documentation project that gets scheduled for "when things slow down." It's closer to infrastructure: the layer that makes the data pipeline explainable six months after the fact, to a team member who wasn't in the room when the decisions were made.
The cost shows up gradually. A team re-derives a threshold it already figured out. A new hire spends two weeks reconstructing context that used to live in one person's head. An audit or a customer question about how an edge case was handled turns into an afternoon of archaeology through old chat logs. None of that shows up on a dashboard, which is exactly why it's easy to underinvest in. Physical AI teams already treat their data pipeline as core infrastructure, worth real engineering time and real budget. The knowledge about that pipeline deserves the same treatment — and the same ownership.
For a practical starting point, see AFFiNE’s guide to building a team knowledge base and self-hosting options.