985 canonical fields defined. 45 vendor packs across 19 verticals. ISA-95 categorized. Ships as a Docker container.
The semantic dictionary your platform framework needs. Take any AI agent and make it work on any machine from any manufacturer: 13 protocols, one canonical schema, governed data from any machine on the floor.
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. Forge reads data from your equipment. It never sends commands. Your machines are safe.
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 proof of concept. 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.
985 canonical fields defined with declared units and types, resolved from 2,086 curated vendor mappings across 19 verticals and 13 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, which is what an audit, an SLA, or a safety review actually requires.
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 13 industrial protocols: MQTT, Modbus TCP, OPC UA, BACnet, ROS2, J1939/CAN, MAVLink, MTConnect, EtherNet/IP, PROFINET, REST, CSV, MachineMetrics GraphQL. 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.
Of the 15 transports the kernel declares, 13 are available: MQTT Sparkplug B reads metrics but does not yet decode protobuf payloads, and SNMP and Modbus RTU ship no client. Reach serial through a Modbus TCP gateway.
Read-only. Forge reads data from your equipment. It never sends commands. Your machines are safe.
Raw vendor tags become universal fields. 2,086 cross-OEM mappings across 45 vendor packs. 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 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 record that is reproducible and verifiable against its corpus version 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.
Your plant engineer sets hard boundaries for your equipment. The kernel enforces them on every reading, the same way every time, whichever model your agent runs on. No human approval step, no rubber-stamping, no latency.
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. Your operators stop babysitting approval prompts and start doing their actual jobs.
An engineer writes the rule in plain English. The kernel either enforces it exactly or refuses to store it — it never stores a rule it understood differently from how you wrote it.
A raw door tag reads 1 on a Haas and 1 on a Fanuc and means the opposite thing. An agent handed that either guesses or stops. Given the resolved state and the rules, it does the job: we measured the same task refused on raw tags and completed correctly on canonical ones.
A rule in a prompt is only as good as the model reading it, and that changes with every upgrade and every cheaper model you swap in. Enforcement happens outside the model, so it applies the same way to any model you run.
Which agent, which rule, which rule version, and the reason — written to an append-only log, with deletes kept as soft deletes so "who removed the spindle limit, and when" stays answerable. A careful agent that simply declines leaves you nothing to show. This leaves a record either way.
Value bounds, rate-of-change limits, physics-validation failures, and compound rules like "spindle load above 90% AND coolant above 45°C." A rule that could never be satisfied, or could never fire, is rejected when you write it rather than sitting on the dashboard doing nothing.
Agents can read your guardrails and test a proposed value against them before attempting anything, and that check is free on every plan. What they cannot do is create, edit, or disable a guardrail. That takes a human.
Two agents can each propose a change that is legal on its own and illegal in sequence. Commands to a machine are serialised, so the second is judged against what the first actually did — or refused, with both outcomes on the record.
Forge is read-only: it never sends commands to your machines, and your operators remain the only ones who can act on equipment. The guardrail decision travels with the result, so the record is part of what you were served.
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 →
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.
Paste your fnet_ API key to switch to live mode.
No key yet? Get your API key, takes about 2 minutes.