[ agent platform × governance ]
In the agentified ERP, the agents are built into the system: you talk to them, but you do not define them. This platform turns that relationship around. Here, business users create their agents themselves: they choose the language model, describe the behavior, assign tools and knowledge, and assemble agents into teams, while a governance layer checks every single action. This page shows how the platform is built, the decisions behind it, and the experience gathered along the way.
Choose the model, describe the behavior, assign the tools: the agent is born in the business team, not in IT.
Teams of agents come together on a canvas, with handoffs as simple rules.
A shell around every activity: no tool call without a check.
Anything critical goes to the inbox as an approval and may wait there for weeks.
[ governance: the shell around every action ]
The common worry goes: hand AI agents to the business teams and you lose control. So the technology stays with a few experts, and scaling never happens. My experience from this platform is different: business teams can very well build and run their own agents, if control does not stand as a barrier at the entrance but wraps every activity as a continuous shell. No tool call, no output, no interaction happens unchecked, whether an agent works alone or as part of a team.
The roles are clearly divided: the business team describes what the agent should do. The platform checks what it actually does. And the human decides wherever something is uncertain or consequential. That turns governance from a brake into the prerequisite for scale.
[ building agents without code ]
A platform does not prove itself in the demo of a single agent but on the way there: how does a business team without technical knowledge get from an idea to a running, secured agent? Every virtual employee passes through these stations.
[ Describe ]
The agent takes shape in four steps: task, behavior, capabilities, collaboration. No prompt engineering needed; the platform composes the system instruction from governance, behavior, and tool knowledge. Before: a ticket to IT and waiting.
[ Connect ]
Over 800 toolkits are available, from CRM and project boards to DATEV, plus your own documents as knowledge. Every agent reaches only what it was given, and says so openly when access is missing. Before: sharing credentials and hoping.
[ Orchestrate ]
On the canvas, agents are connected into teams. Handoffs are simple rules in everyday language: a count is at least three, an answer is yes. The platform translates that into the framework's terms. Before: workflows only developers could change.
[ Secure ]
Seven checking components wrap every action, from input through tool calls to output. Each one can be observed or enforced individually, so control is introduced step by step instead of all at once. Before: prohibition or blind flight.
[ Approve ]
Whatever is uncertain or consequential lands in the inbox as an approval card. The decision may wait for days: the case lives on in the database and runs exactly once after approval. Before: decisions lost in a chat thread.
[ Improve ]
Agents remember facts from conversations, weighted by importance and with time decay, cleanly separated from document knowledge. Evaluations score every run. Before: every conversation starts from zero.
[ architecture ]
The same principle applies here: separate the levels strictly. The interface makes agents accessible to business users, agentOS wraps every activity as the control layer, and the runtime executes teams, with knowledge, memory, and tools. The agent framework stays replaceable; the governance does not.
A no-code builder and a visual canvas for business users
The builder leads to an agent in four steps, entirely without prompt engineering: the platform assembles the system instruction itself, in a fixed order from governance through behavior to the output protocol. The business team only describes what the agent should be able to do and which tools it gets.
The canvas translates the framework's concepts into everyday language: handoffs between agents are if-then rules like a count is at least three, and target states are called back to the user or end the conversation. What the business user clicks becomes clean framework code in the background.
Seven team templates, from customer service to analysis, make the start easy: the roles come prefilled and can be adapted.
The governance shell around every agent activity
Seven checking components work in a fixed order: an input filter against manipulation attempts, rate limits for cost, a tool guard, policies, a loop guard, an approval guard, and an output review. Three tiers take turns: fixed rules first, then rules with model support, and the language model only as the last resort. That keeps governance fast and cheap.
Each component can be switched individually: off, observe, enforce, without restarting the platform. Governance is introduced like a process: observe first, review the findings, then enforce. In doubt the rule is fail-closed, better to stop than to let through. And every decision lands in an immutable log.
Whatever is uncertain goes to the inbox as an approval card. An approval is claimed atomically so it runs exactly once, even when two processes access it at the same time.
Agent teams with knowledge, memory, and tools
Teams run as group conversations with five orchestration patterns, from a fixed round robin to model-driven speaker selection. The handoffs follow the rules from the canvas.
Knowledge and memory are strictly separated: per agent, one index for uploaded documents and one for facts from conversations, weighted by importance and with time decay. Nothing mixes, and nothing is visible to other users.
Tools come from a catalog of over 800 toolkits, exposed through six meta tools instead of thousands of individual definitions, the same pattern as in the agentified ERP. Nine language models from four providers are available, each with a visible hosting label.
[ lessons ]
The hardest part of this platform is not the agent but the time in between: an approval may stay open for days or weeks. That is why the state lives in the database rather than in a cache or a chat thread; a two-week-old approval executes exactly like a fresh one. And every execution is claimed atomically: a double click on approve does not send a second email.
Just as important was removing things again. A memory feature that suggested recently used tools to the model produced silent failures in live tests and was taken out. Four model-driven governance components were deleted without replacement once fixed rules made them redundant. Maturity also means being able to delete.
And because trust needs evidence, the platform audits itself: a two-round audit with findings precise to file and line, about two thirds of them closed in the second round. The open items sit documented in the repository, not under the rug.
[ numbers ]
7
checking components wrap every action, individually switchable: off, observe, enforce
over 800
toolkits connected through six meta tools, from CRM to DATEV
5
orchestration patterns for agent teams, chosen on the canvas without code
4 weeks
an approval may wait: the case lives on in the database and runs exactly once
[ technology ]
Wondering how AI agents could work in your company, creating value and staying under control? Then let's talk: you bring the challenge, I bring the experience and the tools.
