AI Intelligence Layer // Enterprise
Your AI runs without an intelligence layer — nothing that understands the request, gets it the right context, or accounts for what it cost.
grāmatr sits in the request path and runs every call through five things: it classifies the intent, delivers the right context so the model returns better answers for fewer tokens, enforces your policy, attributes every token to a session and operator, and compounds what it learns. Governance is one of the five — what a real layer gives you.
THE MODEL
grāmatr is the platform. Anneal and other applications run on it.
grāmatr is the reasoning and intelligence layer. Applications are built on top of it and inherit its classification, context delivery, governance, cost attribution, and compounding intelligence — they do not re-implement them.
grāmatr's own SaaS application, live on the platform today — running on the same intelligence layer offered to enterprise.
A financial-governance application built on grāmatr — policy and attribution enforced in the request path.
A targeted conversational application on the NEXT90 Insights & Data Engine — built on grāmatr, inheriting classification, context, governance, and attribution in the request path.
Build your application on grāmatr and inherit the full intelligence layer — classification, context delivery, governance, cost attribution, and compounding — from day one.
HOW IT WORKS
One request path. Every call. Before the model responds.
Every AI-enabled request in your organization enters the API path. grāmatr receives it before the model does.
grāmatr classifies intent, resolves organizational context, and loads relevant entities into the session.
intent_class
context[]
Policy is checked. Cost center assigned. If a rule blocks the request, it stops here. The model never sees it.
cost_attribution
The enriched request reaches the model. The audit record is written before the response returns.
session_closed
THE FIVE PILLARS
Five pillars. One intelligence layer. Every AI request.
grāmatr classifies every request before context is assembled. The type of request determines what is relevant — context is targeted to the classified task, not generic.
Organizational memory, project state, and operator history load into the session before the model fires. Sessions are not cold — the model receives exactly what it needs to produce a governed response.
Every request is evaluated against your governance rules before it reaches the model. Non-compliant requests stop before the model fires — policy is enforced in the path, not applied after the fact.
Each request is attributed to an operator, team, and cost center. Cost data is written at the session boundary, not reconstructed by guesswork at the end of the month.
grāmatr writes a complete audit record for every interaction — intent, context, cost, governance outcome — available at query time. That record feeds back: classification and context improve as your organization uses the layer.
THE LAYER IN PLACE
What changes when the intelligence layer is in place.
| Dimension | Without grāmatr | With grāmatr |
|---|---|---|
| Cost attribution | Per-call spend, unattributed. End-of-month reconciliation by guesswork. | Every call attributed to operator, team, and cost center at session boundary. |
| Audit trail | None. Session data lives in model provider logs, not yours. | Immutable record per session: intent, context, cost, governance outcome, operator. |
| Context persistence | Cold start on every session. Engineers re-establish context manually or not at all. | Organizational memory loaded before the model fires. Sessions are stateful by default. |
| Governance enforcement | No rules execute before the model responds. Policy is applied after the fact, if at all. | Governance rules evaluated in the request path. Non-compliant requests stopped before the model fires. |
| SOC 2 readiness | AI layer is outside your audit perimeter. The model provider's SOC 2 covers their systems, not your usage of them. | grāmatr's interception layer, session handling, and attribution chain are in scope. |
IN PRODUCTION
Infrastructure in deployment, not in a deck.
grāmatr's own SaaS product — Anneal — operates on the same interception layer, classification, context delivery, attribution, and audit offered to enterprise clients. SaaS sessions and enterprise routing run through the same layer, in the same deployment. Not a simulation. Not a staging environment.
Cost routing observed: 1M ungoverned tokens on Opus cannot match 150K context-loaded tokens on Sonnet with grāmatr — not because the task was simpler, but because grāmatr loaded context the human operator would not have thought to provide. Classification determined what was relevant. The model received more information than any unaided prompt would carry. Sonnet outperformed Opus because grāmatr compensates for what human operators inherently forget. Illustrative, pending your own baseline.
Type II target: April 15, 2027. Audit scope covers the interception layer, prompt handling, session storage, and the attribution chain — not just the application tier.
Start fast on multi-tenant grāmatr Cloud — available now, tenants isolated at the database row level, never commingled. Then private cloud and on-premises (committed September 1, 2026), or fully air-gapped on-premises (committed January 1, 2027) when the perimeter demands it. Same classification, context delivery, governance, attribution, and audit trail across all four. No shared tenancy in private or on-premises tiers — your session data and organizational context never leave your perimeter.
Anthropic, OpenAI, Google, and Meta model APIs. grāmatr's interception layer is model-agnostic — classification, context delivery, attribution, governance enforcement, and audit trail are consistent regardless of which provider handles the request.
THE FIRST APPLICATION
License Anneal. Skip the build.
Enterprises can license Anneal — the first application built on grāmatr, running in production today — on grāmatr Cloud (available now), private cloud and on-premises (committed September 1, 2026), or fully air-gapped on-premises (committed January 1, 2027). Start with a cloud subscription today and add a perimeter deployment as each tier comes online. AI applications on the full intelligence layer, at any scale — without building the infrastructure yourself.
Learn about Anneal licensing →TECHNICAL SPECIFICATIONS
What your platform team needs to know.
Session data lives in your perimeter — not in your model provider's logs. grāmatr retains session content for 60 days by default, configurable to your application's needs; the governance audit trail — classification, policy decision, and cost attribution — is retained separately and longer for your compliance record. On multi-tenant grāmatr Cloud, organizational context is stored in a tenant-isolated store with row-level security enforced at the database layer — never commingled. Private cloud, on-premises, and air-gapped on-premises deployments store session data in your infrastructure, under your key management. No model changes required. No prompt format changes required.
Licensing is scoped to your deployment model and organizational needs — administration designed to survive personnel turnover. We map it to your environment in a scoping conversation rather than a public rate card. Talk to us to scope your licensing.
Supports Claude, GPT, Gemini, and Llama endpoints. SDK wrapper and reverse proxy deployment options. No fine-tuning. No prompt engineering changes required.
grāmatr classifies every request in under 100ms (~26ms typical); the full contextual intelligence packet assembles in ~135ms. Supporting resources and organizational memory load dynamically, just in time as the agent needs them. If the grāmatr layer is unreachable, requests pass through to the model unmodified. Governance enrichment resumes automatically on recovery.