Enterprise AI agents
you can control and audit

A model can answer questions. An agent can finish the work.

Business does not pay for well-written text. It pays for completed work: a contract reviewed against policy, an invoice reconciled and ready for posting, a disputed case delivered to the right person with the justification already attached.

A model saves time on a single request. An agent removes manual work from the flow: for example, 25,000 documents a month can pass with almost no human involvement, and people handle only the exceptions.

Only an agent can be allowed into systems of record. It has rights, limits, an audit trail and a human who confirms irreversible actions. A model stays in the chat; an agent enters the process.

• —No actions. A model answers with text. An agent takes action.
• —No tools. A model cannot open a record in the ERP, look up a policy clause or call an RPA robot.
• —No process memory. It does not know that the task is on step 3 of 7, that an employee has already decided, or that the regulation changed yesterday.
• —No pause. An agent stops when it finds a discrepancy, waits for a human decision and continues. A model just returns an answer.
• —No rights. A model knows nothing about Active Directory or that an employee is not allowed to see salaries. An agent works strictly within the rights of the person who launched it.
• —No accountability. A model’s answer cannot be signed off and audited later. An agent leaves a record: who decided what, which rule was applied and which version ran.
• —No specialisation. An agent is built for a specific function, such as legal, accounting or procurement, with its own regulations, steps and allowed tools.
• —No flow. A model answers once. An agent works through thousands of documents a month under one scenario, with metrics and reporting.

In short: the LLM is the brain. The agent is the brain plus hands, tools, memory, rights and rules. The platform provides everything except the brain.

The LLM is the engine, and an engine without a car goes nowhere. Primo Epic is everything else that turns the model into an employee your security team will allow into accounting systems and contracts:

• —Rights. Sign-in through Keycloak, Active Directory or your OIDC provider. The agent cannot have more rights than the employee who launched it, and rights are checked on every action.
• —Guardrails. Step limits, a tool allow-list, input and output filters and personal-data masking. They work independently of the model: even if the model makes a mistake, the guardrails stop it.
• —Human-in-the-loop. Reading runs freely. Writing to an accounting system, posting a payment or rejecting a counterparty happens only after an employee confirms, on a card showing what it was, what it will become and why.
• —Audit trail. Who decided what, which rule was applied and which agent version was used.
• —Versioned policies. A methodologist updates rules without developers. Running tasks continue on the version they started with.
• —Agent builder and ready agents. Ready scenarios for finance, legal, HR, procurement, logistics and records management; your own agents on a no-code canvas.
• —Connectors and execution. MCP servers, Primo RPA robots for systems without an API and Primo AI Server for document recognition. Queues, workers, checkpoints and a confirmation queue, built for thousands of documents a month.

Without a platform, every team has to build approvals, rights, logging and versioning in code for each agent.

Yes, with an employee’s confirmation.

Reading is not restricted. By default, any action that writes data, posts a document or triggers a payment waits for an employee’s decision. The employee sees a card with the original value, the proposed change, the rule applied and the reasoning. Responsibility stays with the employee. Systems with an API are connected through MCP servers; systems without one, through Primo RPA robots.

An agent as a whole cannot be signed off, but four specific decisions can. Responsibility is shared by four roles:

• —Agent author — publishes the agent version.
• —Administrator — sets the guardrails after the security review.
• —Methodologist — maintains the versioned policy.
• —Employee — decides on every individual change.

All sign-offs, the step log and the access log stay inside your environment.

Running tasks are not affected.

• —Policies are versioned. A new revision does not affect tasks that already started; they finish on the version they began with.
• —The model is a catalog entry. Switching it does not require rebuilding agents.
• —Quality is re-checked on a control sample before the switch.

• —The agent reads and analyses freely.
• —Any action that changes data waits for confirmation.
• —The employee sees a decision card: original text or value, proposed change, regulation clause and the model’s reasoning. Each change is accepted or rejected separately.
• —Confirmation rules are fixed when the agent is published and can only be tightened at run time.
• —By default, no data-changing action runs without approval.

Yes. Primo Epic includes a no-code builder: agents are assembled from ready blocks — model, knowledge, tools, policies, scenario and audit. You can:

• —use ready agents for common tasks: contract review, invoice verification, spreadsheet analysis, policy questions;
• —build your own agents with your team;
• —build them together with Primo or a partner.

No. You can start small.

• —The platform itself runs on CPU servers, with Docker Compose or Kubernetes.
• —For the model, you can use your existing inference server, a corporate gateway or a cloud model approved by your security team. Any OpenAI-compatible model works.
• —GPUs are needed only if you host the model yourself, and capacity is added as volume grows.
• —A typical start is two servers: one for the platform, one for the model. Hardware is added as the number of users and agents grows.

By industry estimates, only around 7–10% of AI pilots launched in 2025 reached production.

The main reason is accountability. Until someone can sign off on the agent’s actions — with rights, an audit trail and human approval for changes — security and audit will not let it into real systems. Primo Epic provides that control layer, so the first approved agent becomes the template for the next ones: security reviews only the new agent’s rights.

Agents decide; robots execute.

A robot repeats steps that are written down. When an exception falls outside its script, the agent handles it: it collects the documents and data, checks them against your rules and either prepares the result for approval or hands the decision to an employee with its reasoning. When a system has no API, the agent calls a Primo RPA robot through Orchestrator. The robot stays deterministic and controlled, and both run under the same rights and audit.

No.

The platform, data, files and logs stay on your servers, as does the model if you host it. No telemetry is sent out. Outbound connections go only to the model, systems and tools you explicitly approve. With a locally hosted model, the platform works without internet access.

Savings depend on the process. On high-volume document flows such as contracts, invoices and claims, typical patterns are:

• —thousands of employee hours a month moved from manual review to exception handling;
• —the equivalent of dozens of full-time employees freed for higher-value work on the largest flows;
• —shorter processing time and fewer errors against your rules.

As an illustration, 1,000 documents a month at 12 minutes each is 200 hours of employee time, or $60,000–120,000 a year at a fully loaded cost of $25–50 per hour. Exact figures are calculated in the assessment and pilot from your volumes and current manual effort.

About a month for one process:

• —1 week — process assessment and baseline metrics;
• —2–3 weeks — pilot on one process with success criteria agreed before the start;
• —access and policy rules are finalised based on the pilot results.

After the first agent is approved, the next agents reuse the same policies, rights model and audit.