01
One layer, not more wiring
Every new assistant, report or script is usually wired to each system it needs. Each one works. Together they become a web nobody can map.
Four ways of working with four systems already means sixteen links, and the systems need links of their own. Every link has its own login, its own idea of who is allowed to do what, and its own way of failing. When a system is upgraded, each link is checked again. When someone leaves, their access is removed in each place it was granted.
Smart Forge changes the shape. Each system is connected once, to one layer. What the system can do is published there as tools, with the rules that apply to them. Chat, screens, reports and agents all work through that layer, so a fifth way of working does not need four new integrations. It needs none.
Today: point to point
22 integrations to build and maintain
With Smart Forge: connect once
4 connections, reused by everything
02
Anyone can build an agent. Few can run one in production
Building an AI agent has never been easier. A capable team can have one answering questions in a week. The difficulty starts the moment it has to touch real systems, with real data, for real people.
Somebody has to connect it to each system and keep the connection alive. The agent has to act as the person who asked, not as an all-powerful service account. It needs rules about what it may read and change, a way to ask before it changes anything, and a record of everything it did. And each new capability tends to mean new code: written, compiled, built, deployed, and an application restarted.
None of that is the agent. All of it has to be built again for the next agent, and the one after. This is the work Smart Forge does once, for every system and every agent.
| Concern | With Smart ForgeIncluded, for every system | Building it yourselfFor every agent, for every system |
|---|---|---|
| Connections | Each system is connected once, and every tool, agent and screen reuses it | A connector per system, rebuilt for each project |
| Identity | Every call runs as the person who asked | A shared service account, so nobody can say who did what |
| Guardrails | Read-only by default, approvals and sensitive-data rules, set per agent | Rules written into each agent |
| Environments | Dev, Test and Prod connections, chosen when the work runs | Separate builds for test and production |
| A new capability | A tool is a definition and a query or script, reviewed in git and live once approved | Write a service, build it, deploy it, restart the application |
| Audit | One record of every call: who asked, what ran, on which system | Logs spread across every application |
| The AI model | Any model, chosen for each chat or run | Tied to the provider the code was written for |
The agent is the easy part. Everything around it is the product.
03
What the layer is made of
At the bottom are your systems, unchanged. Above them, one connection per system knows which environment it points at. The cognitive layer sits on top of the connections: the tools that say what each system can do, the domains that translate business words into fields and codes, the agents and skills that use them, and the guardrails, identity and audit that apply to every call.
At the top is wherever people work: a chat, a screen, a dashboard, an agent running on a schedule, or another AI tool connected over MCP. They all use the same tools and pass through the same rules.
Any AI model
A provider, your cloud or your own serversSees only what each mode allowsThe AI model sits outside the layer and can be swapped. It can be a hosted model from any provider or one that runs in your own cloud or on your own servers, chosen for each chat or run. Read about bringing your own model.
04
Adding a system is a set of tools, not a project
Common systems are supported out of the box. When you run something we have not seen before, we build the integration with you. Either way, what is added is small: the connection and the tools that describe what the system can do.
Everything else is already there. The new system gets the same identity rules, the same guardrails, the same environments and the same audit as every other system on the layer. Nobody builds those again for it. A tool is a definition and a query or a script. It is reviewed and approved in git like any change, and once approved it is available to the whole organisation.
Adding a system
- Connect itCommon systems are supported out of the box. For the rest, we build the integration with you.
- Publish its toolsWhat the system can do is written as tools, then reviewed and approved in git.
- Use it everywhereChat, agents, screens, reports and other AI tools can use the new tools at once.
Already handled by the platform: connection, identity, guardrails, environments and audit.
05
From answers to decisions
The questions a business asks range from a single fact to a decision. A shared layer can serve all of them, because each kind of question uses the same tools in a different way.
The first kinds are answered directly. The model picks a tool, the tool runs, and the answer is exact and repeatable. Further up, the questions need judgement: the model has to plan, read results from several systems, and explain what they mean. That is what Reasoning Mode and multi-agent orchestration are for.
- Transactional“What is the status of order 48290?”01
- Contextual“Why is this order on hold?”02
- Predictive“Which orders will miss their date this week?”03
- Economic“What revenue is at risk, and where?”04
- Causal“Which decision caused this delay?”05
- Prescriptive“What should we do, and in what order?”06
06
Where your data goes, and where it does not
The layer runs inside your environment. Your systems and your connections stay there. What reaches the AI model depends on the mode, and in both modes it is decided by the layer, not by the model.
In Operational Mode the model receives the question and descriptions of the tools, never data. It answers with what to run, and that runs inside your environment, as you, with the results going straight to your screen. Because what to run is saved, the same request can run again later with no AI at all.
You
1Ask
6Result
Inside your environment
Smart Forge
Your data never leaves. Running it again needs no AI at all.
- 2Question and tool descriptions only
- 3What to run
Model provider
Sees: the question and the tool descriptions. Never your data.
In Reasoning Mode the model plans the work, so it chooses the tools and their arguments. The tools run inside your environment, as you, on the chosen connection. The model then sees the results, because it has to reason about them, but only after the guardrails have masked the sensitive values. It drafts the answer, and you receive it as text, a chart or a PDF report.
You
1Ask
8Result
Inside your environment
Smart Forge
Connections never leave.
- 2Question, instructions and allowed tools
- 3Tools to call, with arguments
- 6Results, after the guardrails
- 7The answer, drafted
Model provider
Sees: your question, the tools it called and their results, after the guardrails.
07
Work that runs on its own
The same layer runs agents that nobody has to ask. A deployed agent is given a standing goal and a schedule. It wakes up, reads what it needs, decides what matters, and acts through the same tools and guardrails as a person in a chat.
then the loop runs again
08
Five gates between a request and an action
A request in plain language can mean several things. Before anything runs, the layer makes sure the action is allowed, understood, attributed to a person, aimed at the right environment, and recorded.
“Release the urgent orders”
Gate 1
ToolsIs this allowed?Only the agent's own tools. Read-only by default.Gate 2
DomainsWhat did they mean?Business words map to fields, codes and arguments.Gate 3
IdentityWho is acting?Runs as the person who asked.Gate 4
EnvironmentWhere does it run?On the chosen Dev, Test or Prod connection.Gate 5
SafetyWhat happened?Approvals, sensitive-data rules and a full audit trail.Chat, deployed agents and other AI tools over MCP all pass the same five gates.
09
Inside your own applications, too
The layer is not only for Smart Forge's own chat and screens. Your own applications and portals can use its tools over MCP, the open standard AI tools use to talk to each other. A view in your application calls a tool and shows live data. A button calls a tool that changes data. Alongside your application, deployed agents keep working in the background.
Nothing is rebuilt for this. The tools and connections your application uses are the same ones everything else uses.
Your application
Your systems
ERP toolWMS toolWMS write toolTMS toolEach tool runs on its system through that system's own connection.
- Live, not batchEach view calls a tool when it is opened. One token opens one system's tools.
- Act from the viewTools that change data, such as release or allocate, run with your application's own connection token, and every call is logged.
- Work in the backgroundAlongside your application, deployed agents keep watching, follow up and report.