Under the hood
The platform that makes your agents reliable and accurate
You do not need to know any of this to launch an agent — Loxtep builds the company brain. But if you want the technical picture, here is the Enterprise Context Layer underneath: connected data, approved context, governance, and one source of truth your agents reach through MCP, REST, SQL, SDK, streaming, or graph.
The full lifecycle
From an idea for an agent to one your business can rely on
Describe the agent you want. Loxtep builds the company brain with you — AI-assisted, human-approved — so the agent ships reliable, not risky.
Tell Loxtep what your agent will need
"My support agent needs to answer order questions and handle exceptions." Describe the outcome — Loxtep maps the company brain, not the agent logic.
Loxtep figures out what the brain needs
The platform identifies the systems, entities, workflows, and definitions the company brain needs — and what context is missing.
The platform builds the company brain with your approval
Loxtep proposes the workflows and definitions, shows its evidence, and asks for your decision where human judgment matters.
You build your agent on trusted context
Wire your agent — in Cursor, Claude, Slack, your own stack — to Loxtep through MCP, SQL, API, or SDK. It reads reliable, current data from the company brain instead of guessing.
Why agents stall
Most agent projects never leave the pilot
Demos are easy. Production is hard — especially when your data, tools, permissions, and infrastructure were never set up as a company brain an agent can rely on. That gap is where budget goes to die.
The data isn’t trustworthy
Agents act fast — stale exports or conflicting definitions turn a wrong answer into a business problem, not just an embarrassment.
What Loxtep handles
Live business data and approved definitions — context your agent can rely on instead of inventing.
Integration becomes the whole project
A useful agent needs several systems working together — for a small team, wiring that up quietly becomes the job instead of the agent.
What Loxtep handles
Loxtep connects your tools and builds the company brain with you, so integration isn’t a side quest.
There are no guardrails when the agent acts
Handing an agent access without clear permissions, scopes, and an audit trail is risky — especially without a security team to backstop mistakes.
What Loxtep handles
Fail-closed permissions, human approval where it matters, and a record of what changed and why.
Not every “agent” is an agent
Plenty of tools wear the label but only chat over documents or fire rigid triggers — that’s not reasoning across your business and acting on live context.
What Loxtep handles
A real foundation for agents that plan, act, and stay connected to how your business actually runs.
Your team becomes accidental data engineers
If launching an agent means pipelines, schemas, and weekend debugging, most businesses stall at the prototype — no matter how good the model is.
What Loxtep handles
Describe the outcome in plain language. Loxtep builds the company brain — you stay focused on the agent.
There’s no first job to point at
“Let’s try AI” drifts — agents ship when they’re tied to a specific job your team already cares about, with a clear before and after.
What Loxtep handles
Start with a concrete wedge: support, ops, revenue, onboarding, or reporting — not a science project.
Infrastructure becomes your problem
Storage, sync, permissions, and scaling underneath an agent is a second product most teams never meant to build or maintain.
What Loxtep handles
The company brain runs underneath. You don’t babysit servers or own 2 a.m. data incidents.
Loxtep builds the company brain underneath — data, context, governance, and infrastructure handled — so you can launch agents your business can actually trust.
What makes a company brain real
The substrate your agents run on
Loxtep connects your tools, governs company knowledge, and delivers it however your agents and apps need it — MCP, REST, SQL, SDK, streaming, or graph.
Inside the company brain
Three integrated layers that make your organizational knowledge permanent, trustworthy, and useful to AI — not throwaway prompt fragments.
AI-Ready Data + Knowledge Graph
Governed, structured data assets and their interconnections — the factual foundation that AI systems read from and reason over.
How Loxtep delivers this
Governed data products (source + consumer) on a real-time streaming backbone; entity context graph; catalog discovery.
Semantics + Ontology
The meaning layer — definitions, relationships, canonical keys, namespaces, and vocabulary that let AI resolve ambiguity and speak the organization’s language.
How Loxtep delivers this
Semantic layer; lexicon and thesaurus; ontology concepts and relationships; namespace mappings; vocabulary inference from connected systems.
Skills (Procedures + Norms)
Encoded procedural knowledge (“how work gets done”) and the access norms that constrain agent behavior.
How Loxtep delivers this
Organizational Skills via the process graph; Agent-Scope Skills via scoped skill bundles; decision traces.
What Loxtep Does With It
Five capabilities that discover knowledge, manage its lifecycle, learn from usage, deliver it to any system, and keep it trustworthy.
Context Mining
AI-assisted reverse-engineering of business operations from connected systems and runtime signals, producing candidates for human review.
How Loxtep delivers this
Automated discovery from procedure inference, vocabulary inference, catalog analysis, query history, and decision traces. Exposed via loxtep_review MCP tool (context mining operations).
Context Development Lifecycle (CDLC)
The managed lifecycle of a context artifact — draft → in_review → approved → deployed → retired — with versioning, dependency tracking, and change propagation policies.
How Loxtep delivers this
Lifecycle management via loxtep_review MCP tool, extending schema versioning, workspace versioning, and lineage impact analysis with change propagation.
Compounding Learning Loops
The mechanism by which episodic experience (decision traces) is promoted, after eval/review/certification, into durable semantic or procedural memory that future agents inherit.
How Loxtep delivers this
Memory promotion from decision traces through pattern detection, review, and certification into durable organizational knowledge. Observable via the Compounding_Metric (certified_procedures_over_time).
Activation & Retrieval
The many delivery formats through which one governed knowledge layer is consumed by different systems. One source of truth, many ways to access it.
How Loxtep delivers this
MCP, REST/API, SQL/Analytics, Webhooks/Streaming, Typed SDK + CLI, and Graph/Entity Context — all from the same governed layer.
Governance & Observability
The controls that keep context trustworthy — access control, quality enforcement, lineage tracking, PII handling, and observable metrics that prove the layer is improving.
How Loxtep delivers this
Role-based access control with fail-closed enforcement; quality rules; lineage and impact analysis; PII tagging; governance flags.
Why governed context matters
Stop thinking in terms of data in a table. Think in terms of a governed data product.
A complete data product is more than the table. It's the semantic layer, lexicon, thesaurus, ontology, and process graph — plus consumption, governance, lineage, quality, and security. That's how your systems and your AI get one coherent, discoverable, governed picture.
Discovery — semantic layer and the whole picture
A table tells you columns and rows. A governed data product tells you what every field means, how it relates to other data, and how to find it — through a semantic layer agents can search instead of inventing.
- ·Semantic layer: searchable business definitions, metrics, and artifacts
- ·Lexicon: what things are called and what they mean
- ·Thesaurus: how terms relate and map across systems
- ·Ontology: how concepts connect and what depends on what
- ·Process graph: how data is produced, linked, and traced through decisions
Consumption — how it's used
Data that can't be consumed reliably might as well not exist. Every governed data product includes consumption interfaces and contracts — so context is discoverable and usable by your apps and AI.
- ·APIs, webhooks, and streaming interfaces
- ·Who can access what, and under what contract
- ·Declarative SLA and freshness metadata (consumed by monitoring, not enforced at runtime)
Governance, lineage, quality, security
AI that reasons over your data needs to know it's correct, traceable, and safe to use. Governed data products bundle governance, lineage, quality, and security so the context you feed to AI is trustworthy and auditable.
- ·Governance: policies, access, compliance frameworks, and audit trails
- ·Lineage: where data came from and where it goes
- ·Quality: rules, checks, and fitness for use
- ·Security: classification, PII, and audit trails
How Loxtep solves the context problem
Loxtep doesn't hand AI raw tables. It models and serves governed data products — with semantic layer discovery, consumption interfaces, governance, lineage, quality, and security built in. That's how we deliver the context your AI needs to reason instead of guess.
Why this is critical in the AI world
Governed context is what separates AI that reasons from AI that hallucinates.
AI needs context, not just bytes
Models that only see tables hallucinate relationships and meanings. Semantic layer, ontology, lineage, and quality give AI the structure to reason instead of guess.
Explainability requires lineage
When AI recommends an action or answers a question, you need to know where the data came from and how good it is. Lineage and quality metadata make AI outputs auditable and trustworthy.
Governance at the edge
AI that touches production data must respect access control, PII handling, and compliance. Every governed data product carries governance and security metadata — so you scale AI without scaling risk.
How agents talk to the brain
One company brain, many ways in
Loxtep doesn't force you onto a single interface. One governed company brain is delivered through many dialects — MCP, REST, SQL, SDK, streaming, graph — each linking back to the same source of truth. Whatever surface you build your agent into, there's already an activation path.
MCP
Model Context Protocol — the hosted tool surface AI agents call directly.
Loxtep surface
mcp.loxtep.io — 19 grouped tools with OAuth 2.1 authentication
REST/API
Traditional HTTP endpoints for platform operations and integrations.
Loxtep surface
Organization-scoped API with role-based access control
SQL/Analytics
Query context and data products with SQL for reporting and ad-hoc analysis.
Loxtep surface
Execute queries, list tables, inspect schemas — all via SQL
Webhook/Streaming
Event-driven consumption — subscribe to changes as they happen.
Loxtep surface
Real-time event streams with replay and queue-based delivery
Typed SDK
Programmatic access with full type safety and IDE autocomplete.
Loxtep surface
@loxtep/sdk + CLI (init, generate, test, deploy)
Graph/Entity Context
Traverse entity relationships and query organizational knowledge as a graph.
Loxtep surface
Entity context, ontology relationships, and decision traces
Build on the brain
Tools for agents and the people building them
CLI, MCP, and typed SDK on top of your company brain — so you ship agents that read live context and stay inside the rules, not demos that fall apart in production.
// .loxtep/generated/index.ts — produced by `loxtep generate`// Every data product and connector becomes a typed constant.import { workspace, defineDataWorkflow, on } from '@loxtep/sdk'export default defineDataWorkflow({name: 'ingest-orders',triggers: [on.connectorEvent(workspace.connectors.shopify_main)],async handler(ctx, event) {// Upsert into a governed data product — typed at compile timeawait ctx.toolbox.upsert(workspace.dataProducts.orders_source,event.payload,)},})
workspace.dataProducts.orders_source is generated from your instance. Accessing a field that doesn't exist fails at compile time, not in production.
Governed data products
Versioned, cataloged datasets with schema, lineage, quality rules, and consumption contracts. The unit of work is a product your org owns — not a one-off pipeline output.
Real-time streaming workflows
Ingestion and enrichment flows on an event backbone. Data moves continuously through transforms and validations — built for streaming, not batch glue code.
Semantic layer + ontology
Canonical terms, namespaces, and mappings agents can resolve. Search business definitions and artifacts instead of guessing column names from a wiki.
Data governance by design
RBAC, PII tagging, quality rules, access requests, and audit-friendly lineage enforced when you build and consume — not buried in documentation.
Catalog, lineage, discovery
Search the catalog, trace lineage impact, review evidence, and see governance flags before you ship or deprecate a data product.
AI context
Entity context, decision traces, and process intelligence wired to the platform. Agents query structured org knowledge instead of inventing relationships.
CLI lifecycle, end to end
init → attach → generate → test → deploy. Scaffold a project, link an instance, generate typed context, test locally, and deploy workflows and data products from your terminal.
Hosted MCP + scoped skills
Connect Cursor, Claude, or any MCP client over OAuth. Nineteen scoped skills teach agents the platform model — data products, governance, semantic layer — with fail-closed enforcement.
Typed SDK from your instance
loxtep generate compiles your data products, connectors, and queues into typed constants. Reference every resource by name with compile-time safety.
Why your agents are reliable
Enterprise-grade reliability, without the enterprise team.
“Reliable and accurate” is not a promise — it is what the platform enforces underneath every agent you launch.
Connected to live systems
Agents read current business data from the company brain, not stale exports or scraped dashboards.
Approved business knowledge
Definitions and process rules are reviewed and approved, not invented on the fly.
Respects permissions
Every agent stays inside the access and scopes you set — fail-closed by default.
Full audit trail
See what changed, why, and who approved it. Nothing happens in the dark.
Improves with use
Successful patterns become reusable memory in the brain, so your next agent starts smarter.
It gets better over time
Your agents get smarter as your team uses them.
Every time an agent handles a task, Loxtep learns what worked. Those patterns become reusable memory in your company brain — so your next agent inherits what the last one figured out, instead of starting from scratch. And that knowledge stays yours, in your account, no matter which AI model you use.
The loop repeats — every week your agents know a little more about how your business actually runs.
Why agents need a company brain
Not another integration project
Most stacks help you move data. Loxtep builds the company brain — so your agents get trusted, live business knowledge instead of another pipeline to babysit.
Stop wrestling with data plumbing. Start building on your company brain.
Join the waitlist for early access. Connect your tools, let Loxtep build the company brain, and ship knowledge agents your business can rely on — without an enterprise data team.
Enterprise-grade reliability, permissions, and audit trails — without the enterprise team.