Technology
Collections that index themselves. An agent harness with rails built into the frame. Experiences that compose from blocks. A governance fabric that wraps all of it. This page walks the whole architecture, layer by layer — and every section links into the Botminds Academy, where each subsystem is taught in full.
Layer 1
Work arrives as documents, records and institutional knowledge. A collection is where it becomes computable: typed, indexed, lifecycle-managed. Choosing the right category is the first design decision of every solution.
Loan files, claims, invoices, tickets. Each record rides a lifecycle with stages, owners and inbox queues; agents work the file, humans gate the decision, and every transition lands as an auditable event.
Policies, SOPs, playbooks, prior art. Auto-vector-indexed on arrival, so agents ground their answers in your institution's own rules — and retrieval cites the exact passage, page and section.
Entities, deals, assets, people. Schemas with typed fields, inferred on ingest and refined by you. The same citation discipline applies: every value traces to the source it came from.
And one you never create: Drive — the project's governed file surface: stage files, browse storage, feed collection connectors. Ingestion is connector-fed: watched folders, SharePoint, cloud storage, mail-in addresses, crawls and APIs — sources re-checked on schedule, not once.
Layer 1 · the operating model
A collection is not a folder — it is a small operating model. Taxonomy says what things are and what they say. Lifecycle says how work moves. Tags let people annotate; events let systems react.
Every new Processing collection is seeded with an 8-stage flow whose motto is AI recommends, two humans confirm, the platform remembers. When policy allows and confidence clears the bar, files go straight through — untouched by human hands, fully logged.
Two jobs, kept distinct: classification (a tree of labels agents assign — what a thing is) and extraction (typed fields agents fill — what it says). Bulk-import a taxonomy you already have; refine it in place.
Stages are programmable: 11 automation types can fire on entry — run an agent, call a webhook, notify a role, set fields. The Auto-Decide policy card defines exactly when AI may skip the reviewers — and when it must not.
Tags are the human layer — free-form labels people stick on records to slice queues and dashboards. Events are the system layer — every stage transition can notify, trigger and integrate downstream.
Layer 1 · retrieval
Some questions are exact — a name, a number, a clause id. Some are meaning — "indemnification carve-outs like this one." Every knowledge collection runs both engines, and both answer inside the scope you attach, with citations.
Landing in a knowledge collection means chunked, embedded, indexed — searchable by meaning within minutes of arrival, no separate indexing project, no nightly batch.
The corpus is watched: coverage, freshness and failures surface on an Index Health view. A passage an agent can't find is a diagnosable event, not a mystery.
Retrieval is scoped to the collections you attach — corpora you didn't attach can never leak into an answer. Answers carry page-level citations, so trust is checkable, not assumed.
Layer 2
An agent here is a harnessed worker: instructions, tools, memory and guardrails assembled in a frame that evaluation holds to account.
Varieties are not model choices — they are job descriptions. The harness is the same; what changes is the shape of the work.
The expert you ask. Grounded Q&A over knowledge collections — every answer cites the passage it stands on.
The analyst who fills forms. Documents in, typed fields out, page-level precision — the workhorse of document AI.
The officer who rules on cases. Applies your policy to the evidence and produces a recommendation with a confidence you can gate on.
The writer who produces artifacts. Memos, letters, summaries — drafted from governed context, not from thin air.
Guardrails live in the runtime: allowed tools, allowed data, policy checks on outputs, escalation the moment confidence drops. Autonomy is a dial you set per agent, not a leap of faith.
Bring the model to the job — frontier or fast, hosted or via your managed gateway. The harness, guardrails and evals stay identical when you swap the engine underneath.
Describe the job in plain language and the builder assembles the agent — instructions, tools, output schema — as a starting point you refine, not a black box you inherit.
Layer 2 · at scale
When one worker isn't enough, the platform gives you three escalating shapes — teams for conversation, xflows for determinism, mesh for scale. Same harness, same governance, different topology.
A leader agent works with member agents in one live run. The coordination mode is the single most important choice: it decides how the leader uses its members.
The leader delegates sub-tasks, then synthesises the answers into one.
The leader picks the one member best suited to the request and hands off.
All members run in parallel on the same input; the leader merges the results.
Output pipes member to member in order — extract, normalise, summarise.
A visual DAG of typed nodes: agents, conditions, loops, webhooks, transforms. Same input, same path, every time — and every run is captured for replay.
A durable, queue-backed pub/sub DAG with dynamic 1→N fan-out and fan-in. One loan file or ten thousand: same topology, more workers. Survives restarts; throughput is a worker count, not a rewrite.
when the work is one conversation — a leader and members reasoning together, in-process, all agents.
when the pipeline must be deterministic and replayable, with conditions, loops and mixed node types.
when it must be durable and scale — queue-backed stages, dynamic fan-out, restart-proof runs.
Layer 2 · reach
Tools are what an agent can do; skills are what it knows about how to work. Both are governed objects — versioned, allow-listed, auditable — and the whole surface speaks MCP in both directions.
Search, extraction, collections, lifecycle, messaging, web — 195+ tools across 35 modules, each with a typed input schema. Import a prebuilt tool or define your own; attach per agent, never globally.
A skill is written know-how — a procedure, a rubric, a house style — the agent loads when the situation calls for it. Packs bundle skills into a capability you install as one unit.
When the job is deterministic, write it as a function and give it to the agent as a tool — the judgment stays in the model, the arithmetic stays in code.
Layer 2 · proof
Agents ship when they pass evals, and keep passing them in production — the same discipline you'd demand of code. The Crew view shows every run as it happens; the evaluation harness shows whether it's getting better or worse.
Your hardest real cases, curated with expected outputs. The eval suite is an asset that compounds — every production miss becomes a new case.
Change a prompt, swap a model, add a tool — the gate tells you what improved and what broke before your users do.
Watch a team think: every member step, every tool call, every hand-off captured. A bad answer is a traceable answer.
Layer 3
Agent output becomes useful inside the way a team actually works. Pages assemble from cards; cards bind to collections and agents — so your process reaches your screen the day you shape it, without a frontend project.
Drag a card — a spread, a summary, a checklist, a chart — onto a page in the designer. Packs are pages that know each other: install a whole experience at once.
The working spread for a file: extracted fields beside the source, page-level citations one click away, annotations where reviewers actually look.
Ask across a collection or the whole workspace — both engines, permission-scoped, every answer grounded and cited.
Lifecycle stages become queues; queues become an inbox with owners. Dashboards read the same events, so the numbers and the work never disagree.
The fabric
Every layer above runs inside the same fabric — built for the people who answer to bank examiners, CISOs and general counsel. The centerpiece is the confidence gate: AI does the work, humans own the decision, and every correction teaches.
Your policies encoded as runtime constraints — first-class objects with scope and review cadence. Exceptions surface and escalate; they never silently pass.
Every agent action logged: which document, which value, which tool, which policy, which human. Built for the exam, not reconstructed for it.
Four-Eyes review where you define it: L1 corrects, L2 approves. Agents prepare; named people decide.
Traces per agent step, run history per workflow, token and latency budgets with alerts. When something drifts, you see it first.
Role-based access down to collection, stage and action level. Least privilege as the default posture, not a hardening project.
Your data, your indexes, your runs — isolated. Encryption in transit and at rest. SSO/SAML.
For builders
The platform is a surface, not a silo: key-authenticated APIs, MCP in both directions, embeddable experiences and a hub for distributing what you build.
Key-auth REST for the canonical loop: push documents, trigger jobs, poll status, pull typed results. Built for the system that calls you at 2am, not just the demo.
POST /api/runtime/v1/jobs/{jobId}/runsPlug your MCP servers into agents — or point your IDE and copilots at Botminds as an MCP server and drive collections, agents and runs from outside.
mcp: tools · resources · both waysDrop a governed surface — a page, a chat, a workspace — into your own portal. Same RBAC, same audit trail, different chrome.
<iframe src=".../share/…">Package agents, pages and collections as an installable solution. Publish, version, install across workspaces — build once, ship many.
publish → install → upgradeUnderneath
The unglamorous parts are the point: the platform is engineered to be boring at 2am.
Mesh workloads run on queue-backed workers — pub/sub topics decouple stages, so throughput is a worker count, not a rewrite. Fan out to the size of the book.
Xflows and mesh runs are captured end to end: inputs, outputs, retries per node. Re-run yesterday's pipeline and get yesterday's answer — or a diff you can explain.
Live dashboards over queues, indexes and workers, with token and latency budgets that alert before users notice. Drift is a page, not a surprise.
SSO/SAML on the front door, encryption in transit and at rest, isolated tenants — the checklist your security review expects, ready before it's asked for.
Every subsystem on this page is taught in full — with screenshots, build-alongs and reference tables — in the Botminds Academy, free. Or bring your architects: the demo can be a whiteboard session — your stack, your constraints, our engineers.