Building one agent is a demo.
Running a hundred is a factory.

Medallion architecture

Bronze holds raw, immutable source data. Silver conforms and deduplicates it. Gold is modeled to the business. Each tier is materialized and independently testable, so a bad transform doesn't silently poison everything downstream.

Golden layer

The gold tier, modeled to your business entities. It's the only surface agents and BI are pointed at — nothing queries raw tables directly.

Change data capture

Log-based replication from source systems, so changes land continuously rather than in nightly full loads. Agents act on current state, not last night's snapshot.

Lineage

Column-level provenance captured at write time rather than reconstructed after the fact. Every field traces back to its source, its transform, and the job run that produced it.

Artifacts

Pipelines, models, tests, and deployments are versioned artifacts in source control with a review workflow — not configuration clicked together in a UI that nobody can diff.

Ontology

The typed graph of entities, relationships, and attributes — what a customer, contract, or claim is in your business, and how they connect. Agents reason over this rather than guessing from table names.

Semantic layer

Metric and dimension definitions resolved at query time, so "net revenue" compiles identically whether it's asked for by a dashboard, an API call, or an agent.

Bitemporality

Two clocks: valid time (when the fact was true in the business) and system time (when we recorded it). This is what lets you reconstruct exactly what an agent knew at the moment it decided — the difference between an audit and an argument.

Governance

Row-level, column-level, and masking policy bound to the data and enforced in the semantic layer, so it holds regardless of which tool or agent is asking.

Policy-as-code

Access and behavior rules stored as versioned, reviewable code moving through the same pull-request workflow as everything else. Skills are policy: reusable, tested, and promoted rather than pasted into prompts.

Control plane

A runtime registry of every agent, tool, and connection, sitting in the path of every call. See → understand → control → improve, with the AI Firewall as the enforcement point.

Scoped write access

Read and write permissions granted per tool and per method, not per user. An agent can read the whole CRM and write to exactly one object, with approval gates on the calls that warrant them.

Agent tokens

Non-human identities with their own credentials, scopes, expiry, and revocation — decoupled from employee accounts, so revoking an agent doesn't mean disabling a person.

MCP

Model Context Protocol, the standard for connecting agents to tools and data. Every MCP server is registered, permissioned, and traced through Lens rather than wired up ad hoc by whoever built the agent.

Evals

Versioned suites of real cases run before promotion, with regression gates. Failures return the full trace — prompt, tool call, result, write — not just a score.

Assembly, not authoring

An agent is composed from a workflow template, a set of versioned skills, registered tools, and the context layers beneath it. Almost nothing is written from scratch per agent.

Promotion path

Every agent moves dev → eval → production through the same gate. Nothing reaches production without a passing eval run and an owner attached.

Decision record

Each run writes back what the agent decided, what it changed, which policy authorized it, and what context it used. That record lives in ContextDB alongside the data itself.

Human-in-the-loop

Approval routing on the actions you flag as high-impact, with the request, the proposed change, and the supporting context presented together so the reviewer isn't rubber-stamping.

Forward-deployed delivery

Our engineers build inside your environment and your repos, and hand over a system your team can operate — not a black box with a support contract.

pip install harnessx

A Python SDK, open source under MIT. Typed functions become tools from their hints and docstrings; MCP servers are discovered and validated the same way local tools are.

Permissions in the code path

Every tool carries ALLOW, ASK, or DENY, with iteration limits and a per-run cost budget. The permission model your engineers write against is the same one Lens enforces in production.

Durable runs

Run state, tool results, and pending approvals persist to SQLite or Postgres, so a run survives an application restart and resumes where it stopped rather than starting over.

Model fallback

Retry policies with capped waits, and a fallback chain to another model or provider on transient failure — configuration, not a rewrite.

Flight recorder

Capture a run's model and tool boundaries, export a portable .hx incident file, and inspect the timeline offline without spending a single new model call.

Delegation

A lead agent hands focused work to specialist agents with their own tools and context, and their results return to the parent. Research, analyze, and write are three agents, not one overloaded prompt.

Skills

Task-specific instructions loaded only when needed, so the context window holds what the current step requires instead of everything the agent might ever do.

OKF knowledge

Open Knowledge Format bundles searched with BM25F. Matching concepts come back with their provenance attached, and links lead to related facts when one answer isn't enough.

Typed decisions

The companion Jev SDK handles routing, classification, and answer review as typed decisions inside the workflow — structured outputs rather than parsed prose.

Extensions

Tools, hooks, and state packaged as a unit and installed into any agent. This is how a capability built for one customer becomes available to the next.

Real-time voice sessions

Low-latency speech in and out over a live session, with the same permissions, policy checks, and decision record applied as any other channel. Voice is a front door, not a separate product with its own rules.

Visual workflow canvas

Compose multi-step processes visually, with every node bound to a registered tool or agent — so what gets drawn is what gets governed, rather than a diagram that drifts from the running system.

ADK / SDK

For teams building on top of DataGOL rather than inside it: the same agent contract, permissions, and tracing, in your own codebase and on your own release cycle.

Embeddable widgets

Drop a conversational assistant into any page or app under scoped credentials, so an embedded agent can never exceed what its host is entitled to see.

Published endpoints

Expose a finished agent as an addressable endpoint your own systems can call, with the same gateway, budget, and audit path in front of it.

Any model, your keys

One gateway in front of every provider. Bring your own keys and contracts rather than renting ours, and swap models without touching agent code.

Automatic failover

Provider outages and rate limits route to a fallback instead of taking your agents down with them.

Budgets and limits

Hard spend ceilings per agent, per tenant, and per user, with cost attributed by model, agent, user, tenant, and step — so an expensive agent is a line item, not a surprise.

Policy checks

Every call passes the policy layer on the way out. This is the AI Firewall: the single interception point in the path of all model and tool traffic.

Traces

Full waterfall per run — prompt, tool call, result, write — with the provenance spine showing which policy authorized each step and under whose identity.

Drift monitoring

Flags agents whose behavior changes without a config change — a reasoning path growing from 9 to 23 tool calls over a week is caught before the invoice is.

Skills Doctor

Names the cause of a cost or quality regression and proposes the prompt or skill change, rather than leaving you to read traces until you find it.

Adoption analytics

Which agents are actually used, by whom, and how often — the number that tells you whether the deployment worked.

Enterprise identity

SSO-backed human identity, with agent identities registered separately so attribution never collapses into "someone's service account."

Tenant isolation

Strict separation of data, context, and credentials per tenant — built for multi-tenant SaaS, not retrofitted onto a single-customer install.

Guardrails

Content, PII, and behavior checks applied in the path rather than asked for in a prompt, so they hold when the model doesn't cooperate.

Immutable audit

An append-only record of configuration changes, grants, denials, and writes. A denial is recorded as carefully as an action — the agent tried, it had no grant, Lens refused on the agent's token.

Durable memory

Memory that persists across runs and across agents, held in the substrate rather than stuffed back into a prompt each time.

Knowledgebases

Unstructured sources — documents, transcripts, tickets — indexed against the same ontology as the structured data, so retrieval and reporting agree.

Replay

Re-run any decision against the context and policy that were in force at the time, not today's. This is what bitemporality buys you.

Portability

Context, skills, and policy are exportable configuration. The system is yours to operate, not a managed black box you rent access to.

// Confirm the five descriptions above, plus voice and the workflow canvas, before this page goes anywhere — see the note in chat.