DataFab / Platform / Knowledge & Agentic Studio
Layer 2 · the builder
Inside the Studio, words to a governed agency.
The build surface of DataFab — where the enterprise composes, tests and publishes its own governed agencies, from its own documents, in its own language, and on its own schemas. Not a bench of specialists, and not a vendor engagement for every new workflow.
01 · the builder
Everything needed to compose governed execution.
Build, test and publish data-driven agents, design workflows, define widgets and orchestrate multi-agent solutions. You build the agencies — on your schemas, in your language. The Studio does the wiring, the testing and the governance.
Domain discovery
Extract schemas directly from the documents you already have.
Data-driven agents
Schema-bound processing units — the unit of execution.
Visual pipeline builder
Drag-and-drop composition with live validation, no code required.
Planning from language
Build an agent from a plain-language description of the outcome.
Chain of agents
Orchestrate sequential work with human gates wherever judgement belongs.
Graph of agents
Non-linear orchestration — branching, fan-out and fan-in. Planned.
Widgets
Visual interface components the analyst can drive directly.
Datasets
Structured, schema-bound data available to every agent.
Utilities
Reusable API and agent components, published for others to compose.
MCP integrations
Connect — and author — your own connectors.
Unified tool catalogue
Every built-in node, fabric service and connector in one searchable place.
Template library
Pre-built workflows to start from rather than a blank canvas.
The approach
From words to a governed agency.
Describe the outcome. The Studio derives the schema, plans the pipeline, and hands you something to test — built from what you already have. The wiring, the schema-mapping and the guardrails are built for you.
Describe
Say what the agency should do, in plain language. No query language, no orchestration syntax.
Derive
Schemas are extracted from your own documents — specifications, policies, contracts, forms.
Plan
A query plan and pipeline are generated for you, and imported straight into the visual builder if you want to shape it.
Test
Run it in an isolated sandbox against sample files, and validate output against the schema before anything is published.
Publish
Set it live, scoped and governed, with runtime placeholders mapped and access permissions applied — reusable by anyone entitled to it.
Why compose rather than buy
Vanilla stands beside the estate. An agency stands on it.
A vendor product reaches one system at a time, and the next deployment starts again. An agency composed here is built on the resolved estate, so it applies everywhere the moment it is published.
You stop renting process and start accumulating an asset. The full argument, including what each route keeps costing and what it leaves you owning: Don’t buy vanilla →
Two hands on the same tool
A business user and a platform engineer, on one artefact.
The Studio meets each where they are strongest — and both routes converge on the same governed artefact: schema-bound, sandboxed, human-gated and audited.
Business user · tech-novice
Build it in language.
- Describe it in words — planning produces a draft agent
- Upload your documents — domain discovery produces the schemas
- A sentence becomes a pipeline you can see and edit
- Start from a template of pre-built workflows
Expert · full control
Compose it with every node yours to shape.
- Compose in the visual builder with live validation
- Write custom logic and scripts inside the query plan
- Author custom connectors in MCP Studio
- Define schemas and query plans directly in JSON
- Debug step by step with breakpoints and traces
02 · architecture
The builder stack.
A gateway over core builder services, a testing engine, a governed execution engine, planning, and integration into the Knowledge Fabric.
| Band | Layer | Components | Role |
|---|---|---|---|
| 01 | API gateway | Authentication · rate limiting · request routing · health | Every request authenticated and routed |
| 02 | Core services | Agent · domain & schema · widget · dataset · utility · chain | The builder services themselves |
| 03 | Testing & preview | Sandbox runtime · mock data · debug console · preview render | Validate before publish |
| 04 | Execution engine | Pipeline runtime · resource manager · credential vault · state manager | Isolated, governed execution |
| 05 | Planning | Hybrid planner · workflow executor · error handler · recovery manager | Build and run from language |
| 06 | Platform integration | Knowledge Fabric · model services · audit services | Grounded in the fabric, model-agnostic |
The Studio does not only consume the Fabric. It enriches it.
Every governed schema, accepted relationship, published agency, workflow, human decision and execution outcome can cascade back into the Fabric — with provenance, version and authority attached. The enterprise does not merely automate work; its operational knowledge compounds as the work is performed.
The Fabric begins drawn — discovered automatically from the estate. Through the Studio, people also author: schemas, business rules, approval structures, workflow logic, domain interpretation and reusable agencies. Those authored objects become part of the persistent knowledge state. The architecture is neither purely drawn nor purely authored.
03 · data-driven agents
The unit of execution.
An agent pairs a language model with a structured query plan for schema-bounded processing — not a loose prompt, but a governed, reusable unit with a lifecycle.
Definition
Name, description, instructions, model and system prompt — behaviour stated in plain language.
Query plan
The ordered sources and steps the agent runs: datasets, connectors, sub-agents and scripts.
Placeholders
Configurable slots mapped per user at runtime, so one agent serves many contexts.
Lifecycle
Draft, publish, execute with files, and a full execution history — every run schema-bounded and sandboxed.
01Start a new agent
A user initiates creation. Nothing about the process assumes engineering knowledge.
02Pick or discover a domain
Select an existing business domain, or create one by uploading documents — schemas are extracted automatically from what you upload.
03Review the schema
View the generated schemas and shape them: entities added, modified or removed; attribute types and constraints; relationships defined; the domain assigned.
04Define the agent
Name, description, plain-language instructions, model selection and prompt — then the query plan over datasets, connectors, sub-agents and scripts, with configurable placeholders.
05Draft and test
Save as a draft and test interactively: run with sample files in an isolated sandbox, validate output against the schema, iterate, and apply the draft when satisfied.
06Publish and govern
Move from draft to published, configure runtime placeholder mapping, set scoped access permissions, and make it available to others as reusable supply.
04 · domains & schemas
Your schemas, from your documents.
Upload the documents you already have — specifications, policies, contracts, forms — and the Studio extracts the schemas. The domain model is derived, not declared by hand.
Upload
Provide the documents you already run on.
Analyse
Text, structure and tables are extracted.
Extract
Entities, attributes and relationships discovered.
Generate
Structured schemas created.
Refine
You review and adjust interactively.
| Document type | Extraction focus |
|---|---|
| Data specifications | Data models, field definitions |
| Policies | Workflows, rules, roles |
| Contracts & agreements | Parties, terms, obligations |
| Regulatory documents | Requirements, controls |
| Forms & templates | Input fields, validations |
| Schema binding | Purpose |
|---|---|
| Input schema | Validates incoming data structure |
| Output schema | Ensures output conforms |
| Internal schema | Controls intermediate transforms |
| Validation schema | Enforces business rules |
Once bound, schemas govern every agent, and agents pin to explicit schema versions.
05 · build without code
Describe it. See the pipeline.
Write the workflow in a sentence; the Studio generates a pipeline you can preview, refine and run — or drag it together from the node palette. Either way, no engineering bench required.
“Extract client data from the CRM, check it against the sanctions list, and flag high-risk matches.”
Generated pipelineInput → Knowledge (CRM) → Tool (sanctions check) → If / Else (risk) → Output (flag matches) type checking · cycle detection · reachability · permission checks — all validated as you build
The node palette — twelve building blocks
06 · orchestration
Agencies, not agents.
An agency is a coordinated team of agents serving one purpose. Compose several into a workflow, with human review gates wherever judgement belongs. Execution pauses at the gate until a person approves — then continues. Every step signed, isolated and logged.
Sequential with a gate
A → B → [review] → C → D. The straight line, with judgement inserted where it matters.
Branching
A splits to B and C, each reviewed, then merged into E.
Hierarchical
A delegates to two sub-chains that each run their own steps.
Downstream agents can never exceed upstream permissions. Inter-agent messages are signed with a time-to-live. Every human gate blocks until approved, and the approval is recorded with the person who gave it and the basis they had.
The next step extends the linear chain into a full directed graph: conditional branching, parallel fan-out and fan-in, cycles with exit conditions and dynamic routing, with a human gate available at any node.
07 · connect anything
Author your own connectors.
Connectivity is MCP First. When a system you built in-house has no built-in connector, you do not wait for the platform — you author one, have it validated, and publish it to the catalogue yourself.
Built-in nodes, Knowledge Fabric services and connectors sit in one searchable place. Credentials are injected at execution time and never stored in an agent definition.
Author
Define the connector type against the MCP contract.
Upload
Command, arguments, tools and credentials schema.
Validate
Protocol, schema, tool and security checks run before anything is enabled.
Activate
Enabled for your tenant on success.
Publish
Appears in your catalogue for instance creation by anyone entitled to it.
08 · governance
Governed by construction.
Every agent runs inside an isolated sandbox, calls only the tools it is authorised for, receives credentials only at execution, and writes a tamper-evident trail. Governance is not configured on — it is the default.
Execution sandbox
gVisor isolation, read-only filesystem, allowlisted network, time and memory limits.
Tool authorisation
Read-only is automatic, writes are logged, and administrative actions require multiple parties.
Credential injection
AES-256, hardware-security-module backed, injected at run and destroyed after.
Testing & isolation
Unit, integration, security and performance testing in a separate sandbox.
Audit trail
Hash-chained and encrypted, auditor role only, with no delete capability.
Nothing an agency does becomes enterprise truth on its own.
Observed → proposed → validated → approved — and superseded when the evidence changesWhat it builds
An encoded workflow is an asset, not an engagement.
The judgement your people apply a hundred times a week is currently held in their heads and lost when they leave. Encoded once in the Studio, it becomes a governed, versioned, reusable object the organisation owns outright — deployable across every team, every client and every jurisdiction, without a vendor in the loop.
Next step
Build the first agency this week.
The people who know the work compose the agencies, from documents they already have. Bring one workflow and the documents behind it.