01
20,000 Agent Blueprints
The catalog is the cartesian product of 50 industries × 20 roles × 20 functional archetypes — so an insurance claims triage agent and an ITSM intake agent share one vocabulary of capabilities.
Cortex AI · Models & agentsGENEDATA / 01
Intelligence that acts.Control that stays.
Ground AI in your business context. Connect models, tools, and agents with permissions, approval, and evidence built into the workflow.
Shared context · Lineage · Governance
Connected
Your sources
Models & providers
Enterprise knowledge
Tools & services
Connected intelligenceCortex AI
Governance
Business impactGoverned action
Shared contextLineageGovernance
02
Governed Model Gateway
One endpoint across Anthropic, OpenAI, Gemini, Mistral, Cohere, Groq, xAI, and any OpenAI-compatible endpoint — with a circuit breaker, key custody, and per-call cost tracking.
03
Graph-RAG Retrieval
Retrieval runs over a knowledge graph rather than a flat vector index, so an agent can traverse relationships between entities instead of matching passages that merely look similar.
Inside Cortex AI
The catalog and engine Genedata runs on.
Cortex AI is assembled from components already proven across the Genellipse portfolio rather than written fresh for this platform. Genedata consumes the catalog and engine directly, which is why the AI layer arrives with governance already in it.
Agent Catalog
20,000 installable blueprints across 50 industries, 20 roles, and 20 functional archetypes — each carrying a risk tier, expected outcomes, and a setup estimate.
Learn moreModel Gateway
Eight provider adapters behind one endpoint, with a Redis circuit breaker, keystore-held credentials, and per-call cost tracking.
Learn moreKnowledge Graph
An in-memory graph engine with analytics and Graph-RAG, so retrieval traverses relationships between entities rather than ranking loose passages.
Learn moreAgent Runtime
The agentic loop — planning, tool invocation, memory, reasoning, and a safety guard — with citations attached to the claims an agent makes.
Learn moreSkills Registry
Skills declare inputs, output schema, cost band, and visibility. Outputs are validated before they are accepted, so a malformed response fails closed.
Learn moreProvenance & Governance
Hash-chained records with signed receipts, plus rate limiting and spend controls — the same primitives behind the platform's audit trail.
Learn moreAgent Loop
Perceive, plan, act, verify — inside the governance boundary.
An agent with production data access is only safe if every step runs under the same policy and audit as a human user. Each pass through this loop is authorised per action and written to a hash-chained record, so an agent cannot reach data its requester could not — and cannot later deny what it did.
How It Works
Install, ground, gate, account.
Most agent projects spend their first months on scaffolding. Starting from a catalog blueprint moves the work to the part that is actually specific to you.
Install a blueprint
Choose from 20,000 blueprints scoped by industry, role, and archetype. Each arrives with skills, a risk tier, and expected outcomes rather than an empty prompt.
Ground in your graph
Retrieval runs over your knowledge graph and governed tables, so an agent follows real relationships instead of matching passages that merely read similarly.
Gate every call
Prompts pass policy and redaction before egress; tool calls are authorised individually under the invoking identity rather than granted for a whole session.
Account for it
Cost, latency, and the full decision trace are recorded per call into a hash-chained log with signed receipts, so the record can be verified rather than trusted.
Capabilities
What the engine actually provides.
These are components with running code behind them, extracted from workloads already in production across the portfolio.
Planning and reasoning
A planning engine, reasoning engine, and tool registry drive the agentic loop, with a safety guard evaluating actions before they execute.
Multi-agent collaboration
Supervisor and worker agents coordinate over a collaboration bus, so work exceeding one agent's scope decomposes rather than failing.
Agent memory
Managed short- and long-term memory per agent, so a long-running workflow keeps context without re-reading everything each turn.
Citations by construction
The runtime attaches citations to claims as they are produced, rather than asking a model to remember to cite after the fact.
Cost bands and spend control
Skills declare a cost band, and spend controls plus rate limiting apply per tenant — so an agent loop cannot quietly become a five-figure invoice.
Connector catalog
A classified connector library with category profiles and config schemas, so an agent reaching an external system does so through a governed connector.
In Practice
Who this is for.
Agents earn their place where work is repetitive, well-specified, and currently done by a person reading dashboards.
Data Engineer
Triage the 3am alert first
An agent correlates the failing task with recent schema changes, upstream freshness, and similar past incidents before anyone is paged, citing the evidence behind each conclusion.
On-call starts with a hypothesis, not a blank page.
Business User
Ask in plain language, get a governed answer
Questions resolve against certified metric definitions and the knowledge graph, so the answer matches the dashboard rather than contradicting it.
Self-service that cannot invent its own metrics.
CISO / Security
Allow AI without opening a side door
Agents inherit the invoking user's permissions, every model call passes policy and redaction, and the resulting record is hash-chained rather than merely logged.
Agentic workflows with verifiable provenance.
What Changes
What changes when the AI layer is an operating system.
Point-solution AI tools require a copy of your data and answer to a different policy engine than the rest of your stack.
| Dimension | Before Genedata | With Genedata |
|---|---|---|
| Starting point | An empty prompt and a blank project | A blueprint scoped to your industry, role, and risk tier |
| Grounding data | A corpus copied into a separate vector store | Graph-RAG over your own knowledge graph and governed tables |
| Authorization | A service account with broad standing access | Agents act with the invoking user's rights, per call |
| Model choice | One provider, rewritten to switch | Eight adapters behind one endpoint, with failover |
| Evidence | A chat history, if that | Hash-chained records with signed receipts |
20,000Agent Blueprints
8Model Providers
20Functional Archetypes
Hash-chainedProvenance
The next step
The engine is proven before it reaches your tenant.
Cortex AI is assembled from components already running across the Genellipse portfolio — the agent runtime generalised from GENELAW, the model gateway and governance primitives from AegisNow, the knowledge graph from risk workloads. Genedata inherits that engine rather than reinventing an AI layer alongside the data platform.
FAQ
Cortex AI, answered.
What platform and security teams ask before putting agents near production data.
What is Cortex AI?
Cortex AI is the agentic operating layer Genedata runs on — a model gateway, knowledge graph, agent runtime, skills registry, and agent catalog sharing the platform's identity and governance. It is a product line in its own right whose catalog and engine Genedata consumes, rather than an AI feature bolted onto a data platform.
What does 20,000 agent blueprints actually mean?
The catalog generates the cartesian product of 50 industries, 20 roles per industry, and 20 functional archetypes — intake and triage, summarisation, reconciliation, monitoring, and so on. You install a blueprint already scoped to your industry and role rather than composing an agent from an empty prompt, and the underlying skill codes are domain-neutral so the same vocabulary spans verticals.
How is Graph-RAG different from ordinary vector retrieval?
A flat vector index returns passages that look similar to the query. A knowledge graph lets an agent traverse actual relationships — this claim belongs to this policy, which sits under this treaty — so multi-hop questions resolve by following edges rather than hoping the right passage ranked highly.
Which model providers are supported?
Eight adapters ship today: Anthropic, OpenAI, Gemini, Mistral, Cohere, Groq, xAI, and a generic OpenAI-compatible adapter for self-hosted models. A Redis-backed circuit breaker handles provider failure, and provider keys live in a keystore rather than in application config.
Can an agent do something its operator could not?
No. Agents execute under the invoking identity and every action is authorised per call rather than granted as a session capability. Skills declare their output schema and are validated before a result is accepted, so a malformed or unexpected response fails closed.
How is agent activity proven after the fact?
Actions are recorded into a hash-chained provenance log with signed receipts, so a record cannot be altered without breaking the chain — the same primitive behind the platform's audit trail. Verification is a function call rather than a matter of trusting the operator.
Can it run inside our own perimeter?
Yes. The OpenAI-compatible adapter fronts self-hosted models, so an agent can run entirely against models inside your boundary, and the runtime deploys wherever the rest of the platform does — including air-gapped environments.
Related content
Architecture
Cortex AI Reference Architecture
Kernel, model gateway, knowledge graph, and the agent runtime.
CatalogAgent Blueprint Catalog
Browse blueprints by industry, role, archetype, and risk tier.
GuideSkills & Output Validation
Defining skills, output schemas, cost bands, and visibility.
RelatedGeneCatalog
The policy layer every agent action is evaluated against.
Take the next step
Install an agent, not a project.
Pick a blueprint for your industry and role, and watch it run against governed data under full policy and provenance.