1,027 canonical fields · 47 vendor packs · 2,461 mappings · 20 verticals
Raw telemetry from 20 verticals — Fanuc, Haas, Siemens, ABB, and every OEM your customers plug in — translated into one verified schema. Physics-validated. Hash-stamped. Ready for AI agents that need to be right, not just fast.
Developer Sandbox, Free → Platform License →
Normalize any vendor in 30 seconds. One API call, one MCP tool, no integration project. Try the free sandbox →
License the engine. Ship a cross-vendor canonical data model as your feature. Next quarter. See platform licensing →
Read-only by default. The Forge kernel only reads. Commands reach a machine only through the separately deployed Forge bridge, and only when you enable it. The bridge refuses any action it can’t verify against current machine state, records every decision, and never blocks a stop. Forge is not a safety function and does not replace your safety-rated systems.
curl -X POST https://forge.foundrynet.io/v1/normalize \
-H "Content-Type: application/json" \
-d '{"oem": "haas", "data": {"Spindle_Speed": 8500, "CoolantTemp": 24.1}}'{
"normalized": {
"spindle_speed_rpm": 8500,
"sensor_readings.coolant_temp": 24.1
},
"coverage_pct": 100,
"confidence": 0.97
}No sales call. No integration project. Paste your data, see the result. That IS the deployment.
Need the key that goes in
YOUR_API_KEY? Get one free in 10 seconds: email address, no card, 3 machines.
A Fanuc reports spindle speed one way, a Haas another, a Siemens a third, in different units and scales. A frontier model can usually interpret them. But “usually” isn’t a spec: ask twice and the interpretation can change, and nobody owns whether it’s right. 79% of manufacturing leaders say integration challenges and poor data quality limit AI’s real impact (L2L 2026).
Only 15% of enterprises are fully prepared to run agentic AI in production, and the most-cited barrier is data quality and lineage — knowing what a value means and where it came from (Fivetran 2026). A bare “4.2” is ambiguous until someone declares the unit. Forge makes that declaration explicit and carries it with the value.
Gartner expects over 40% of agentic AI projects to be canceled by 2027, citing rising costs, unclear business value, and inadequate risk controls (Gartner). In an industrial setting, an agent decision nobody can reconstruct is a liability. Forge addresses the risk-control piece directly: every reading is validated, versioned, and hash-verifiable.
Not another platform to run beside the one you already have. Forge is the layer that makes your customers' data mean the same thing across every vendor that talks to you — and lets you prove it.
Translation. 1,027 canonical fields across 47 vendor packs and 20 verticals, resolved from 2,461 curated vendor mappings. A Fanuc spindle load, a Haas spindle load and a Siemens spindle load arrive as three different tags in three different units, and leave as one field with a declared unit and type.
Sovereign guardrail. Every reading is deterministic — no LLM, no probabilistic guessing in the path that produces a value. Physics bounds, sentinel detection and type checks run on every reading, and an impossible one resolves to null with a reason rather than to a number your model will treat as real.
Tamper-evident proof. Every normalization ships with an NTE hash over the canonical output, versioned to the corpus that produced it. Re-hash an archived reading in any language and you can show which decision tables produced it — same input, same bytes, every call.
We license to platforms. We don’t sell to your customers. No Forge branding required.
1,027-field canonical schema, 366 resolvable from vendor tags today with declared units and types, resolved from 2,461 curated vendor mappings across 47 vendor packs across 20 verticals and 12 protocols. Every corpus release is versioned, so the reading you stored last year is still interpretable this year.
Physics bounds, sentinel detection, and type checks run on every value. A register boundary or an impossible reading resolves to null with a reason, never to a number your model will treat as real. Confidence travels with the mapping.
Every response carries a corpus-versioned hash over the canonical output. Re-hash an archived reading and you can show which decision tables produced it. Same input, same bytes, every call — so any party can check the record later.
Forge also ships a working agent on its own model — prediction, diagnosis, OEE, shift reports, work orders. That is proof the vocabulary is complete enough to build on, not the product you are buying. See the reference agent →
Forge reads from any PLC, controller, or sensor through 12 industrial protocols: MQTT, Modbus TCP, Modbus RTU, OPC UA, SNMP, BACnet, ROS2, J1939/CAN, MAVLink, MTConnect, EtherNet/IP, PROFINET, REST, CSV. Point Forge at your equipment and it auto-detects the protocol and starts reading. No hardware to install. No PLC code to write. No downtime. Your existing equipment is already compatible.
Read-only by default. The Forge kernel only reads. Commands reach a machine only through the separately deployed Forge bridge, and only when you enable it. The bridge refuses any action it can’t verify against current machine state, records every decision, and never blocks a stop. Forge is not a safety function and does not replace your safety-rated systems.
Raw vendor tags become universal fields. 2,461 cross-OEM mappings across 47 vendor packs across 20 verticals. Your Fanuc's "Spindle_Speed" and your Haas's "spd_rpm" become one universal field: spindle_speed_rpm. The engine handles the messy reality of factory floors: renamed tags, unit mismatches, sentinel values, and offline equipment. Unresolved tags are researched, cached and confirmed, then ship as vendor mappings in signed corpus updates.
One line. Your agent calls 32 MCP tools: normalize, predict, diagnose, calculate OEE, generate shift reports, manage work orders, read and pre-check safety guardrails. Works with Claude, Cursor, LangChain, CrewAI, AutoGen, or any MCP-compatible client.
claude mcp add --transport http forge https://mcp.foundrynet.io/mcp --header 'Authorization: Bearer YOUR_API_KEY'Every agent action is supervised and recorded. Your operations team sees what every agent is doing, approves actions, and has a tamper-evident record of everything that happened.
{
"S1Temp": 72.1,
"S1Load": 847,
"SP_SPEED": 8500,
"aa_000": 3.2
}Four values off the controller. No names an agent can reason about, no units, no scale. 847 could be anything.
{
"spindle_temperature_c": 72.1,
"spindle_load_pct": 84.7,
"spindle_speed_rpm": 8500,
"coolant_pressure_bar": 3.2,
"oem": "haas",
"coverage_pct": 100,
"match_type": "corpus"
}Named, typed, unitized. 847 was tenths of a percent, so it lands as 84.7. aa_000 was coolant pressure in bar. The _c comes from the unit the Haas pack declares for S1Temp — declare it on the tag instead (S1Temp (degF)) and Forge converts. It reads a declared unit; it never infers one.
Same shape from every manufacturer. A Fanuc, a Haas, and a Mazak all return spindle_speed_rpm, so your agent is written once. coverage_pct tells you how much of the payload was mapped and match_type tells you how, so you always know whether to trust the reading.
Docker on any 4 GB Linux host, NUC, or industrial PC. Values never leave your building — only tag names and counts are shared for corpus updates.
No hardware to buy. No industrial PCs. No edge servers. No IT approval process. Forge runs in the cloud, hosted at forge.foundrynet.io. Instant sandbox, full MCP gateway. Your data arrives through the protocols your equipment already speaks. When you want edge deployment, run the same Docker container on any 4 GB Linux host. Same kernel, your choice of where it runs.
AWS Greengrass component. Azure IoT Edge module. Deploy to thousands of devices through your existing edge infrastructure.
Edge for real-time intelligence. Cloud sync for fleet analytics and cross-site learning.
Define hard boundaries for your equipment. If an agent tries to exceed them, the kernel blocks it instantly. No human approval needed, no rubber-stamping, no latency. Your plant engineer sets the rules. No agent can override them.
They don't ask for permission. They enforce the rules your engineers set, at the software layer: a rejected automation never leaves the kernel, and a denied agent never reads the machine. Every block is logged. Your operators stop babysitting approval prompts and start doing their actual jobs.
An engineer writes the rule in plain English. The kernel enforces it deterministically, forever.
"Block if spindle_speed_rpm > 12000." Value bounds, rate-of-change limits, physics-validation failures, and compound rules like "spindle load above 90% AND coolant above 45°C." Parsed once, reviewed by you, then enforced identically on every reading.
Agents can read your guardrails and test a proposed value against them before attempting anything. They self-correct instead of getting silently rejected. What they cannot do is create, edit, or disable a guardrail. That takes a human.
What was blocked, when, why, and which agent tried. Deleting a guardrail is a soft delete with an audit trail, so "who removed the spindle limit, and when" is always answerable. Your compliance team gets proof, not assurances.
Guardrails block any agent-proposed action that violates a rule your engineers set, and log every block. Read-only by default: the Forge kernel only reads. Commands reach a machine only through the separately deployed Forge bridge, and only when you enable it. The bridge refuses any action it can’t verify against current machine state, records every decision, and never blocks a stop. Forge is not a safety function and does not replace your safety-rated systems.
Forge resolves your equipment data, then pushes it wherever it needs to go. Four of these ship as pre-built templates: the field mapping, the exact payload the platform expects, and a curl command that creates the automation. The rest is any endpoint that accepts a webhook.
An integration is a URL, a method, headers, an auth mode, and a JSON body template. If your system accepts a webhook, Forge can drive it, and the condition that fires it is written against a canonical field name that stays the same when you add a machine from a different manufacturer. See all templates →
Per-event billing. The hash is the receipt. Try the engine free on your own machine. Integrate directly through the API. Or license the engine and ship a cross-vendor canonical data model as a feature of your own platform.
docker pull ghcr.io/foundrynet/forge-sandbox. Send your vendor's tags, see what comes back.The corpus is deepest where the equipment is hardest: CNC and robotics. Same kernel runs the rest.
CNC, robotics, and mixed-vendor lines. Connect your agents to Fanuc, Siemens, Haas, ABB, KUKA, and 13 more through one data layer — the arm and the machine it tends in a single schema.
Explore →Also supported on the same kernel: data centers (UPS, PDUs, CRAC units) · energy (inverters, storage, grid assets) · cold chain (refrigeration controllers).
Tell us what you're working with. We'll show you what Forge does with your data.
Or just email foundrynet@proton.me. No sales pitch. Just a demo on your data. Subject line “Evaluation sandbox” gets you a container image and API credentials within 24 hours.
Paste your fnet_ API key to switch to live mode.
No key yet? Get your API key, takes about 2 minutes.