The enterprise platform for banking, insurance, financial services, and single-family rentals. Bring the API keys you already pay for, your own cloud, or open models on your own GPUs — deployed inside your environment, with the deepest support tier we offer.
Multi-user AI platform with SSO, compliance, and live-checked integrations
Enterprise AI Chat — multi-model, multi-persona, streaming responses
AI Team Workspace — multi-agent orchestration
Automations — scheduled AI workflows
Code Studio — five governed job modes
Under contract with Anthropic or OpenAI? Standardised on Azure or Google Cloud? Want open weights on your own GPUs? All three are first-class here — configured from the UI in minutes, mixed freely inside one deployment.
Already have an agreement with Anthropic or OpenAI? The integration is already built. Paste your key and it works — you keep the relationship, the rates and the terms you negotiated, and you stay the customer of record. We never sit between you and your vendor.
Azure OpenAI, Google Vertex AI, or AWS Bedrock — the model runs inside your cloud account, under the enterprise agreement, region, and data-residency terms your procurement team already signed off.
Open models on hardware you own, through the runtime we ship in the box or any OpenAI-compatible server. Keyless — a base URL, not a credential. No meter, no vendor, no egress.
Providers are configured per organization, from the admin UI — no code changes, no redeploy, and no environment variables to talk an ops team into. Add the provider, test the connection before you commit it, save, and your model catalog populates itself.
Pick from eight, paste the credential or base URL
Verified before it is ever saved — no silent misconfiguration
Available models are discovered and seeded for your org
Run an open model on your own hardware and nobody is metering it. Every chat, every crew, every scheduled workflow — and the invoice doesn't move. Put the frontier model where it earns its price and the open one everywhere else.
The platform is self-hosted, so your data sits in databases you control. Choose a self-hosted model and prompts never leave your perimeter at all — there is no outside to leave to. Even Knowledge Base embeddings default to running locally.
This isn't one global switch. Each agent resolves its own model, falling back to its team's default — so a sensitive workflow can stay on local weights while the one beside it calls a frontier model.
Eight providers behind one dispatcher — mix them in a single deployment
Your contract, your keys, your rates
Under the agreement you already signed
Bundled runtime, or any OpenAI-compatible server
Open weights from the labs your board already recognises
The frontier-class open weights teams keep asking for
Whichever door you come through, the rules are the same: a model has to be enabled in your organization's catalog before a single token flows, and that check runs before any credential is read. Reasoning models are handled properly too — on the gateway, chain-of-thought is stripped by default and returned only when you ask for it.
Connect AI outputs to the outside world with a 3-layer event architecture — subscriptions, distribution channels, and messaging bots.
Integrations, security, compliance, and provisioning across four tabs — each card a live check, not a static badge, all run in parallel every time the page loads.
The page renders what your role can actually use. Every card and every editor tab mirrors the gate on the route behind it, so an operator is never handed a form that 403s on save — and a stat tile reads blank rather than zero when a role wasn't shown the cards it would have counted.
Point Code Studio at a repository and pick the job. Each mode brings its own phase pipeline, its own suggested agent team, and its own deliverable — a pull request, a report, or a documentation bundle.
Move a codebase to a named target version — Java, Spring Boot, Python, Node.js, .NET. Ends in a pull request on your target repo.
Translate between languages. You name the source and target language pair; the run ends in a pull request.
Describe a feature and have the team implement it against the existing code. Ends in a pull request.
Analysis that cannot write. There is no commit, push or PR phase to re-enable — the pipeline simply doesn't contain one. Even the build and test phases are absent. You get a written report.
Tick what you want — user guide, manual, implementation details, API docs — and get a downloadable bundle that is exactly what you ticked. Nothing is committed to the repo being documented.
Every mode suggests its own roster — migration engineer, security reviewer, technical writer, API cartographer — and the editor can only offer a member the tools that mode actually grants.
A re-run joins its parent's lineage. Put the whole line side by side — cost, tokens, duration, outcome — and pick the model and price you actually want. Adopt the winner as the project default and every later job that names no model inherits it.
Admins curate the provider/model combos jobs may run on. Curation only ever narrows governance — every entry is re-checked against the org's model policy on each read, and a job naming anything off the list is refused at save time, not at run time.
Where a human gates the run, the decision is written down — who released it and when — and it lands on the run receipt alongside every step the agents took.
Every model call and every agent run emits a span. Leadership gets real adoption data — which teams use AI, which agents earn their keep, where the spend goes — while conversation content never enters the analytics tier at all.
Cost and usage attribution sliced by module, model, user, agent, or the whole org. Token counts, latency, success and failure rates, and dollars — per team, per period.
Prompt and response text is never written to the analytics tier. Spans carry ids, timings, tokens, cost, and status. The audit record carries whitelisted summary fields. Neither stores what anyone typed.
Find the teams AI hasn't reached yet and train them. Find the agents that get used daily and buy more of that. Target enablement with evidence instead of a survey.
Group spend by module, model, user, or agent over any period. Answers "where did the AI budget actually go" — and which investments are paying off.
Walk any run span by span — every model call, every tool, every handoff between agents, with timing and cost at each step. When something misbehaves, you can see exactly where.
Telemetry and compliance are separate tiers on purpose. The audit trail fails closed — nothing is served without a record. Operational traces fail open, so a telemetry hiccup never blocks real work. And when a PII policy is active, a scanner failure captures nothing at all — there is no raw fallback.
Yes. ContextuAI Enterprise separates operational telemetry from conversation content by design. The Observability module attributes cost and usage by module, model, user, agent, or organization, so leaders can see which teams use AI, which agents are used, and what it costs. Prompt and response text is never written to the analytics tier — spans carry only ids, timings, tokens, cost, and status, and audit records carry whitelisted summary fields.
Two separate tiers. Operational traces store span and trace records containing ids, timings, token counts, cost, and status, retained on a TTL of 90 days by default. The compliance audit trail stores whitelisted summary fields describing what was served and what was refused, retained 730 days by default with a hard 180-day floor. Neither tier stores prompt or response text.
Because usage and cost are attributed by team, user, agent, and model, leaders can identify which parts of the organization have not adopted AI yet and target training there, see which agents are used daily and invest in similar capabilities, and measure whether an enablement program actually changed usage — using observed data rather than surveys.
Yes. Conversation content never enters the analytics tier. In addition, when an organization has an active PII policy and PII scanning fails, nothing is captured at all — there is no raw fallback. The compliance audit trail fails closed so nothing is served without a record, while operational traces fail open so a telemetry issue never blocks real work.
ContextuAI Enterprise is self-hosted. You deploy and operate it on your own infrastructure, and all data — including observability and audit data — stays in databases you control. ContextuAI has no access to your deployment or its contents.
One governed timeline per run: what the agents did, which external systems they touched, which model ran each step, what it cost, where a human gated it, and how it ended. Export it as markdown and hand it over.
Workspace projects, crews, agentic workflows, and Code Studio jobs each get a receipt. It joins stores that already existed — spans, checkpoints, approvals, audit, artifacts — so it is one accounting, not a second one.
The export exists to be forwarded, so every string on it is a disclosure decision. Failure text is credential-scrubbed, span attributes are a fixed allowlist, and tool arguments, tool results and prompt bodies never appear.
Admins see any run in their own org; everyone else is pinned to runs they started. Missing, cross-org, and not-yours all return the same 404 — the run-id space isn't probeable by watching status codes diverge.
Instead of a connector count on a slide, every enterprise connector sits in an explicit tier, and a scripted, re-runnable harness produces a record an admin — or a customer's auditor — can read.
Every connector sits in an explicit tier that records how it is really served — vendor-hosted with per-user OAuth, a native API connector, or this deployment's own data plane. No logo wall pretending they're all equivalent.
A fixed harness runs the same checks against every connector — is the target actually registered, does auth resolve, did the activity produce audit events — and writes a record an admin can re-run the day before an audit.
A certification record never contains an endpoint, a credential, or a token, and a check that fails is sanitized rather than leaking the underlying exception. It's designed to be forwarded.
Every check is always present in a record. One that doesn't apply reads skip — a first-class outcome, never a quietly omitted line. Which of your systems sit in which tier is a conversation we'd rather have with you directly than publish on a page.
Enterprise ships a self-hosted Knowledge Base with vector search (Qdrant) — upload your organization's documents and chat gets grounded, cited answers. A built-in Starter Assistant gallery gives every new org a running start instead of a blank page.
Browse a gallery of ready-made company assistants spanning HR, IT, Operations, Finance, Go-to-Market, and Engineering
Admins add a starter assistant for the whole team; any user can add one to their own workspace
Ask questions and get answers grounded in your uploaded documents, with sources cited
Employee handbook, benefits, onboarding, time-off policy
IT helpdesk, security & acceptable-use policy
Standard operating procedures (SOPs)
Expense & travel policy
Sales enablement
Team assistants for product and engineering documentation
The gallery also includes live-data connector cards for teams that want to ground chat in a live system instead of uploaded files.
A domain isn't a theme — it's your systems connected, your vocabulary understood, and the workflows your team actually runs, all under one governed record. We build deep in four.
Core systems, operations, and supervision — with the workflows that cannot deliver anything until a named human releases them.
Claims, underwriting, and policy servicing — assembled from the systems of record you already run.
Research, reporting, and supervision, where an assistant that states what it cannot source is worth more than one that improvises.
Leasing, maintenance, rent roll, and portfolio reporting across scattered-site doors — the operational reporting nobody has time to assemble by hand.
Nothing arrives pre-wired to somewhere else. A bundle declares slots; you bind each one to your own database, API, knowledge base, or MCP server, inside your own network.
Question your own Postgres, MySQL, SQL Server, Snowflake, or MongoDB in plain language, over pooled async connections — with injection guards and column masking sitting between the model and your data.
Save any working project as an org-scoped template and your whole team starts from it — applied server-side, so it behaves the same from the API as it does in the browser.
Some of these arrive with a ready-made library and a seeded environment you can drive on the first call, rather than a slide deck. Ask us what's waiting in yours.
Eight providers behind one dispatcher, one OpenAI-compatible endpoint in front of it, and an admin-editable matrix deciding who sees which screen. Nobody needs a raw provider key.
Anything that speaks the OpenAI API — the official SDKs, Aider, Continue.dev, IDE plugins, a shell script — points at /v1 and works. Every call is authenticated with a scoped platform key, rate-limited per key, and recorded against org, key, and model.
AWS Bedrock, Anthropic, OpenAI, Google, Ollama, Vertex AI, Azure OpenAI, and any OpenAI-compatible endpoint — all dispatched through one chain on your org's own encrypted credentials. An unknown model is a clean 404, never a silent fallback to something else.
Which roles reach which screens is one org-scoped matrix an admin edits — not a hardcoded list in the code. It's enforced on the server before a page renders, and the navigation is filtered through the very same matrix, so the menu can't offer a door that won't open.
Model-access policies, spend budgets, and per-org rate limits are admin-set and checked at both save time and run time. Both fail closed.
Stream audit events to your SIEM over HMAC-signed webhook batches. Each sink keeps its own cursor with exponential backoff, and the signing secret is encrypted at rest and never handed back.
Every URL that comes from a user, persona, or config — API tools, webhooks, MCP targets — goes through an always-on, DNS-pinned SSRF guard that refuses loopback, link-local, private-range, and cloud-metadata destinations.
See how enterprise teams use ContextuAI to transform their workflows
Connect trading databases, compliance systems, and risk models. Query portfolio performance, generate regulatory reports, and detect anomalies in real-time.
Securely query patient databases, research repositories, and clinical trial data. AI personas enforce HIPAA compliance while delivering instant insights.
Connect GitHub repos, manage issues and PRs through chat, migrate and document codebases with Code Studio, and orchestrate multi-agent pipelines. From sprint planning to deployment monitoring.
Everything in Solo, plus managed deployment, team collaboration, SSO, compliance, and dedicated support.
For individuals and small projects
For teams and organizations
/v1Enterprise-grade security, compliance, and collaboration for your entire organization.