MiliAgent decides what to do. MiliFlow lands those actions in approvals and tickets. MiliRAG supplies evidence you can trace. MiliGate governs every model call. MiliEval answers whether the last change actually helped. Each module drops into the stack you already run, or the five together form a complete agent foundation. Every capability is exposed through APIs and plugin extension points, so nothing has to be replaced first.
Plenty of teams buy model capability and still can't put it to work, and the blockers sit at different points: nobody knows what to hand it, the output can't reach the process, the answers have no source, the calls go ungoverned, and after a change nobody can say whether it improved. These five modules map onto those five blockers.
MILIAGENT
A model on its own answers questions; it doesn't move work forward. MiliAgent turns one request into ordered steps, picks the tools, fills in the arguments, judges whether to continue or stop, and pauses for human confirmation before anything risky.
MILIFLOW
Getting one agent running is easy. Getting it into a process that has trigger conditions, approvers and deadlines is not. MiliFlow handles triggers, branching, approvals, retries and rollback, so every run maps back to a ticket number.
MILIRAG
The model doesn't know your policies, contracts or drawings. MiliRAG turns those documents into a knowledge layer that is searchable, permission-aware and able to point back to the exact passage, ready for the two layers above it.
MILIGATE
Every request bound for a model leaves through here: one interface, model selection by policy, rate limits, redaction, per-department accounting and a complete log — so changing provider later never touches application code.
MILIEVAL
Once the path runs end to end, the hard part is saying whether each adjustment helped or hurt. MiliEval builds a baseline from your own business samples and quantifies the difference behind every prompt, model and tool change.
How to choose
Teams that already have a knowledge base and applications usually start with MiliGate and MiliEval, to get cost and quality under control first. Teams starting from scratch tend to pair MiliRAG with MiliAgent, prove one real use case, then expand outward.
Building an agent is not the same as writing a longer prompt. MiliAgent keeps a plan it can revise while it runs: it splits the task first, then re-plans the remaining steps as execution turns up new information. A failed tool call retries under policy, drops down to a fallback path, or hands the task back to a person. Complex work can be divided across roles — retrieval, calculation, drafting and review each own a segment — with a lead agent consolidating the result.
MiliFlow uses a visual canvas to connect agent nodes, human nodes and external systems into a process that actually runs: a new ticket starts it, amount and risk level decide the branch, anything over the threshold goes to a person for approval, and a failure unwinds through compensating actions. Results are written back to the ticketing system, and a confirmation, a follow-up question or a rejection can be handled directly in your enterprise chat tool, with the record synced back to the process instance.
The ceiling on retrieval quality is usually set at the parsing step. MiliRAG first converts two-column PDF layouts, tables that run across pages and scanned files into structured text with the heading hierarchy intact, then chunks on semantics and structure at the same time, so a table or a clause is never cut in half. When a source updates, only the changes sync — there is no full reindex.
The value of a single exit point shows up the day you swap something out and don't have to edit application code. MiliGate exposes one stable API upward and connects downward to commercial model APIs, self-hosted open models and domain fine-tunes, choosing the route by use case, cost ceiling and latency budget, and failing over automatically when the primary model times out or errors. A new model can take a slice of traffic as a canary release first; if the numbers look wrong, the previous routing config comes straight back.
"Seems fine" is not a reason to ship. MiliEval assembles an eval set with reference answers from real tickets, questions and documents, re-runs it on every prompt edit, model swap or added tool, and lists sample by sample what improved and what regressed. After launch it samples live sessions for review and feeds the problems production exposes back into the eval set, so the baseline keeps up with the business.
What decides this is rarely technical preference; it is how far the data is allowed to travel. The three below divide the data boundary and the operational responsibility very differently. None of them is a reduced feature set.
For teams that want to prove the value before investing in infrastructure. Data sits in a tenant isolated per customer, in an availability zone inside the jurisdiction you nominate, and knowledge bases and logs are never stored alongside another customer's. Milisoft handles version upgrades, scaling and on-call cover; your team configures the use cases and watches the results.
For financial and manufacturing work where data cannot leave the internal network. Every component installs in your own data centre or private cloud; model weights, the vector store and audit logs all stay inside the boundary, with support for sovereign hardware and software stacks and offline upgrade bundles. Your team runs it day to day, and we supply deployment scripts, inspection checklists, the upgrade manual and remote support.
For organisations where most data is sensitive but a few use cases need a stronger model. Knowledge bases, logs and business systems stay on the internal network, and only the redacted fragments that are genuinely needed leave through MiliGate to reach an external model. Policy states exactly which fields may leave, every outbound call is recorded, and operational responsibility is agreed separately for the internal and outbound halves.
These are the points buyers press hardest on during evaluation. The full interface list, performance baselines and deployment checklist are in the technical white paper — ask us and we'll send it over.
| Capability | Details |
|---|---|
| Deployment | Managed cloud, private deployment or hybrid — pick one. Private deployment runs either on a Kubernetes cluster or as single-host Docker Compose, with an offline installer provided. |
| Model access | MiliGate connects mainstream commercial model APIs, self-hosted open models and domain fine-tunes through one interface, with primary, standby and fallback order configurable per use case. |
| Identity & permissions | SSO, LDAP and OAuth2 single sign-on; roles and data permissions are inherited from the source system, and retrieval results and tool calls are re-checked against the caller's identity. |
| Audit & traceability | Every session, model call, tool action and cited source is recorded. Logs export to your SIEM or data warehouse, and the retention period is set by policy. |
| Observability | Built-in dashboards for call volume, latency, token cost, failure rate and eval scores, plus Prometheus metrics and webhook alerts. |
| Extensibility | Tools, data sources, document parsers and scorers all connect as plugins, over HTTP or through the SDK, with a local debugging environment included. |
| Deliverables | Source for the custom work, container images and deployment scripts, architecture and interface documentation, the eval set, the operations runbook and role-based training material. |
| Support level | Standard, Professional and Flagship. Response times, on-call hours and regression frequency vary by tier — see service tiers & SLAs. |
Yes. Each of the five has its own API and its own deployment unit. The most common starting points are MiliRAG, to build the knowledge layer, or MiliGate, to consolidate the model calls already scattered across existing applications. MiliFlow on its own can orchestrate human nodes and external system calls; the agent nodes inside a process need MiliAgent, which is a capability boundary rather than a bundling requirement.
No. We sit as a layer above the ERP, CRM, office systems, ticketing and data platforms you already run, connecting through APIs, message queues or read-only database views, without touching their schemas or business logic.
If one system genuinely has no usable interface, we build an adapter for it rather than advise you to replace it.
It depends on which modules you run and where the model sits. If you run only MiliRAG and MiliGate with inference on an external API, three standard x86 servers are enough to start; running open-model inference inside your network means adding GPU servers sized to your concurrency.
During the solution stage we produce a specific configuration list, with the headroom explained, based on your concurrency, document volume and latency targets — so you don't have to buy for the maximum case up front.
Application code usually doesn't change by a single line. Calls all go through MiliGate, so switching provider is a routing config change. The real work sits in prompt adaptation and quality verification, and a MiliEval regression run quantifies that — in most cases the switch can be assessed within a few working days.
The acceptance criteria go into the eval set when the project starts. If they aren't met, the next stage doesn't begin — that is how we contain the risk, and it is your exit point.
When something does regress, MiliEval first locates whether the cause is a retrieval miss, prompt drift or a model version change; we fix that step, then add the affected samples to the regression set so it doesn't happen twice.
No. Under private deployment the data stays entirely inside your environment and we have no channel to it. When an external model API is used, MiliGate redacts before the request leaves, and training on your data is switched off using whatever option the provider offers.
Data use, retention periods and deletion are written into the data processing clauses of the contract; you can also read our privacy policy.
Bring one of your real documents and one action you want automated. In a single demo we take parsing, retrieval, execution and the audit trail end to end, and afterwards give you a module recommendation, a deployment model and an effort estimate for the first stage.