[ agent platform × governance ]
This platform lets you create as many AI agents as you need: you 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 absolutely can build and run their own agents, as long as control is not a gate at the entrance but a shell that wraps every activity. 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 goes through these stages.
[ 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: ban it outright or fly blind.
[ 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 interface makes agents accessible to business users, while agentOS wraps every activity as the control layer. 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. The business team only describes what the agent should do and which tools it gets.
The canvas translates the framework into everyday language: handoffs are if-then rules like a count is at least three. 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 adaptable.
The governance shell around every agent activity
Seven checking components work in a fixed order, from the input filter through tool guard and loop guard to the output review. Fixed rules take effect first, the language model only as the last resort: that keeps governance fast and cheap.
Each component can be switched individually: off, observe, enforce. Governance is introduced like a process: observe first, then enforce. When in doubt, the rule is stop rather than let through, and every decision lands in an immutable log.
Whatever is uncertain goes to the inbox as an approval card. An approval runs exactly once, even when two processes access it at the same time.
Agent teams with knowledge, memory, and tools
Teams run 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 documents and one for facts from conversations, weighted and with time decay. Nothing mixes, nothing is visible to others.
Tools come from over 800 toolkits, exposed through six meta tools instead of thousands of individual definitions. 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.
Taking things back out mattered just as much. 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.
