Transforming Business with AI
An agent is the right choice when a task needs judgment, tools, and context across several steps. When a script, a workflow, or a single prompt does the job, we will tell you that instead.
Oronts designs, builds, and runs agentic AI systems from Munich: agents that call tools and APIs, retrieve the right context, and take actions with a human in the loop where the stakes demand it. Built on open frameworks like Mastra, LangGraph, CrewAI, and the Vercel AI SDK, with OpenAI and Anthropic models, so you own the system and can run it in your own infrastructure.
The stack we build on
Choose an agentic AI system when a task needs judgment across several steps: reading context, deciding what to do, calling tools or APIs, and acting on the result, rather than following one fixed path. An agent fits when the work is too variable for a deterministic workflow but too repetitive and well-understood to keep doing by hand: triage and routing, retrieval over your own documents, drafting and review, multi-step research, and operations that touch several systems. We build these on open frameworks, Mastra, LangGraph, CrewAI, and the Vercel AI SDK, with OpenAI and Anthropic models behind a provider-agnostic layer, so you are never locked to one vendor. The trade is that agents are probabilistic, so they need guardrails, evaluation, and a human in the loop wherever an action is high stakes or hard to reverse. Where a deterministic script, an n8n workflow, or a single prompt covers the need, we say so plainly in the first call. The proof we point to is our own assistant running in production on this website, built on Mastra.
The assistant on this website is an agentic system we built on Mastra, running in production. It is not a demo behind a login: it is the same kind of tool-using, context-retrieving agent we build for clients, and you can use it here before you talk to us.
See our AI workOur agents call tools and APIs and take actions, but the high-stakes ones run with a human in the loop. We design where an agent acts on its own and where it must propose and wait for confirmation, so an irreversible action never happens silently.
We build on open frameworks, Mastra, LangGraph, CrewAI, and the Vercel AI SDK, and keep the model provider behind a layer, OpenAI or Anthropic. The agent logic is yours, in your repository, so a framework or model choice is never a one-way door.
We design the data flow so you control where context and prompts go and which model provider sees what. Where personal data is involved we work GDPR-conscious, sign a German Auftragsverarbeitungsvertrag, and keep retrieval and storage in infrastructure you operate where the case requires it.
A coordinator plans the work and routes it across specialized agents, with explicit hand-offs, shared memory and bounded tools.
Hand-offs are explicit and observable, shared memory carries state across agents, and a human approval gate guards consequential actions.
We define what the agent should do, where it acts on its own, and where a human approves. The output is a scoped design: the task boundary, the tools, the context it needs, and the points where it must stop and ask, before any build starts.
Agents are only useful when they can act. We connect them to your systems through clean, typed tools and APIs, with idempotency and error handling, so a tool call is safe to retry and a failure is visible rather than silent.
We build retrieval over your own documents and data so the agent answers from your knowledge, not its training. Chunking, embeddings, and a vector store wired to the agent, with citations back to the source so an answer can be checked.
We design the boundary between what an agent does autonomously and what it proposes for confirmation, plus input and output guardrails, rate and cost limits, and a clear audit trail, so the system stays inside the lines you set.
We build evaluations that measure whether the agent does the job, and tracing and logging so you can see every step, tool call, and decision in production. Without evals an agent is a black box, so we treat them as part of the build, not an afterthought.
We take an agent from a working prototype to something you can run: cost controls, retries and fallbacks across model providers, prompt and output validation, monitoring, and a deployment your engineers can operate without us in the loop.
Agents act on your systems, so every seat at the table judges them differently.
You want agents you can run and change, not a black-box platform.
Model-neutral agents on open frameworks, your code, EU-hosted, no lock-in.
Agents acting on systems need governance and audit.
Human-in-the-loop approval, audit logging and guardrails, AVV and TOM readiness.
You need a working agent, not a research project.
A bounded agent shipped in a 90-day pilot, then scaled.
Your client needs senior agentic work under your brand.
White-label agent engineering, the same stack behind our public work.
From use-case fit to a launched, owned agent: scoped, built with evaluations, reviewed with a human in the loop, hardened, and run, by senior engineers, with the code and the roadmap in your hands.
We pin down the task, the inputs, the actions the agent may take, and the cost of getting one wrong. We confirm an agent is the right tool here, and if a workflow or a single prompt does the job, we say so before committing.
We design the agent: the framework, the model provider, the tools and APIs it calls, the context and retrieval it needs, and the points where a human must approve. The design is reviewable before code, not discovered during it.
We build the agent and its evaluations together. Evals measure whether it does the job on cases that matter, so a change that helps one path and breaks another shows up before it reaches production rather than after.
We wire the confirmation points: where the agent proposes and waits, what a reviewer sees, and how an action is approved, edited, or rejected. High-stakes and irreversible actions never run without a human deciding.
We add the production parts: cost and rate limits, retries and provider fallbacks, input and output guardrails, and tracing so every step and tool call is visible. The agent stops being a black box and becomes a system you can operate.
We deploy the agent into your infrastructure and hand off the code, the evals, and a runbook so you run it without us in the loop. An optional retainer covers maintenance, evals, model updates, and on-call to an agreed SLA target.
An agentic system adds power and complexity at the same time. Four questions decide whether it is the right tool for your case.
Agents earn their complexity when a task needs judgment across several steps: reading context, choosing which tool to call, and acting on the result, where the path is too variable for a fixed workflow. If the task is a fixed sequence of steps, a deterministic workflow or a script is simpler, cheaper, and more predictable, and we will recommend that instead.
Agents are probabilistic, so an action that is high stakes or hard to reverse runs with a human in the loop: the agent proposes, a person confirms. We design that boundary explicitly, add input and output guardrails, and keep an audit trail, so the system is autonomous where it is safe to be and supervised where it is not.
You control where context and prompts go and which model provider sees what. We keep retrieval and storage in infrastructure you operate where the case requires it, sign a German Auftragsverarbeitungsvertrag, and design GDPR-conscious data flows where personal data is involved. Model calls to OpenAI or Anthropic are scoped to what the task needs.
The agent logic, the tools, the evals, and the prompts are yours, in your repository, built on open frameworks with the model provider behind a layer. There is no Oronts license gate on running or changing it, and any competent engineering team can take it over, so the framework and provider choices are never a one-way door.
The same goal calls for very different tools depending on how variable the task is and how much judgment it needs. This is where a single prompt stops, where a fixed workflow stops, and where an agentic system earns its added complexity.
Scroll sideways to compare all three columns.
| Single prompt | Workflow automation | Agentic + Oronts | |
|---|---|---|---|
| Handles variable, multi-step tasks that are not a fixed path | |||
| Calls tools and APIs and takes real actions | |||
| Decides which tool to use based on context | |||
| Retrieves context from your own documents and data | |||
| Human in the loop on high-stakes actions | |||
| Evaluation and tracing built in for production | |||
| Deterministic and fully predictable output | |||
| Senior engineering team behind it |
A check means it fits the case well out of the box. A minus means partial or needs work. Text cells say what it actually takes. A deterministic workflow stays the better choice where the path is fixed and full predictability matters more than judgment.
Concrete situations where judgment across several steps beats a fixed script, and the outcome the agent plus our engineering delivers.
An agentic checkout assistant that retrieves the right products, checks availability and price through typed tools, and proposes the order for a human to confirm before it commits.
An operations agent that reads the case, decides which tool to call, and acts within set limits, escalating to a person whenever a step is high stakes or hard to reverse.
A support triage agent that classifies and routes each request, drafts a grounded reply with citations back to your sources, and hands the sensitive cases to an agent with full context.
Most teams do not need an agent on day one. We move you up the ladder only as far as the task requires, and we say plainly when a cheaper step already covers the need. Each stage is a working system you own, not a throwaway.
We start with one well-crafted model call where a single prompt with good instructions does the job. It is the cheapest, most predictable option, and for many tasks it is the right place to stop. We tell you when it is enough.
When the task is a fixed sequence of steps, we wire a deterministic workflow or an n8n flow that calls tools in a known order. Fully predictable, easy to reason about, and no model judgment where none is needed.
When answers depend on your own documents, we add retrieval over your data with citations back to the source, so output is grounded in your knowledge and can be checked rather than trusted blindly.
When the work truly needs judgment across several steps, we promote it to an agent that decides which tool to call, with guardrails, cost and rate limits, evaluations, and a human in the loop on every high-stakes action.
We harden the system with tracing, provider fallbacks, and a runbook, then hand off the code and the evals so you run it in your own infrastructure. An optional retainer covers maintenance and model updates to an agreed SLA target.
How responsibility splits between Oronts, your team, and the model and cloud providers on an agentic engagement.
| Responsibility | Oronts | Your agency / partner | You | Model / cloud provider |
|---|---|---|---|---|
| Agent design and orchestration | Oronts owns Agent design and orchestration | |||
| Evaluations and test harness | Oronts owns Evaluations and test harness | |||
| Guardrails and approval gates | Oronts owns Guardrails and approval gates | You owns Guardrails and approval gates | ||
| Prompts, policies and business rules | You owns Prompts, policies and business rules | |||
| Hosting, data and model keys | You owns Hosting, data and model keys | Model / cloud provider owns Hosting, data and model keys | ||
| On-call and incident response | Oronts owns On-call and incident response | |||
| Code and IP | You owns Code and IP |
Oronts works with serious teams that need senior delivery, not low-cost outsourcing.
Exact pricing depends on scope, responsibility, delivery speed, team size, integrations, support expectations and production risk.
Founder-led, senior-only delivery from Munich. Scope your agentic AI use case in one conversation.