What is Cognocient?

Cognocient is an AI spend intelligence platform that proxies every API call your application makes to AI providers — OpenAI, Anthropic, Google Gemini, Mistral, Groq, Together AI, and more. Every request is observed, attributed to a feature or team, analysed for waste, and surfaced in real-time dashboards your CFO can actually use.

The integration is a single configuration change. No new SDKs, no new dependencies, no application code to rewrite.

The problem

58% of organizations describe their AI costs as a "black box" (Capgemini Research Institute, 2025). Engineering teams see token counts in Datadog. Finance teams get a consolidated line item on the credit card bill — weeks later. Nobody can answer:

• Which product feature is driving the cost spike?
• Is this spend waste, or is it generating revenue?
• Are we about to breach our AI budget before the month ends?

Cognocient closes all three gaps — automatically, in real time, without requiring your developers to instrument anything manually.

How Cognocient works

Your application code points at https://api.cognocient.com/v1 instead of the AI provider directly. Cognocient:

1. Forwards the request to the original provider — same API surface, same models, same response format. Your application code sees zero difference.
2. Records metadata — model, token counts, cost, latency, and your optional attribution headers. Prompt and response content are never stored.
3. Runs analytics in-path — waste detection, budget enforcement, anomaly scoring, and cache hit analysis — before the response returns to your app.
4. Surfaces insights — into the Cognocient dashboard, your BI tools via FOCUS 1.1 export, or your alerting pipeline via webhooks.

┌─────────────────────────────────────────────────────────────────┐
│                       YOUR APPLICATION                          │
│  client = OpenAI(api_key="sk-cog-...",                          │
│                  base_url="https://api.cognocient.com/v1")  ←─  │
│                     the only change                             │
└───────────────────────────┬─────────────────────────────────────┘
                            │  POST /v1/chat/completions
                            │  X-Cost-Feature: chatbot
                            │  X-Cost-Department: engineering
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                    COGNOCIENT PROXY                             │
│                                                                 │
│  ① Budget check (Redis, sub-ms) ── over limit? → 429 / degrade │
│  ② Cache lookup (pgvector HNSW) ── hit? → return in <10ms      │
│  ③ max_tokens clamping ─────────── cap to remaining budget     │
│  ④ Attribution tagging ─────────── feature, dept, session      │
│  ⑤ Forward to provider ─────────── with real provider key      │
│  ⑥ Log metadata ────────────────── cost, tokens, latency       │
│                                                                 │
│  10–30ms overhead  ·  Prompt content never stored              │
└───────────────────────────┬─────────────────────────────────────┘
                            │
               ┌────────────┼────────────┐
               ▼            ▼            ▼
          OpenAI       Anthropic      Gemini / Mistral
          GPT-4o      Claude 4       / Groq / Together

The proxy adds 10–30ms of overhead. Budget checks run in Redis (sub-millisecond). Semantic cache hits return in under 10ms — often faster than the provider would have responded.

One change unlocks everything

Change one line. That's it.

from openai import OpenAI
 
client = OpenAI(
    api_key="sk-cog-YOUR-KEY",                    # Your Cognocient proxy key
    base_url="https://api.cognocient.com/v1"       # ← the only change
)
 
# All existing code works unchanged ✓
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}]
)

import OpenAI from 'openai';
 
const openai = new OpenAI({
  apiKey: 'sk-cog-YOUR-KEY',
  baseURL: 'https://api.cognocient.com/v1',        // ← the only change
});
 
// All existing code works unchanged ✓
const response = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello' }],
});

Key capabilities

Cognocient is built around six capability pillars. Each unlocks a different part of the AI spend visibility problem.

Finding features in the dashboard

Each capability maps to a specific dashboard page. Here's where to look:

Read the full Dashboard Walkthrough →

Who Cognocient is for

Engineering teams use Cognocient to understand which features drive AI costs, catch runaway usage before it hits the bill, right-size models with one-click recommendations, and debug anomalies with per-request attribution trails.

FinOps and finance teams use Cognocient to allocate AI spend to the right cost centres, enforce monthly budgets in real time, produce chargeback reports for internal GL accounts, and export FOCUS-compliant data into existing cloud cost management platforms.

CTOs and CFOs use Cognocient's Executive View to answer the board question every quarter: "We spent $X on AI last month — what did we actually get for it?" Unit economics (cost per ticket resolved, cost per report generated, cost per sale influenced) make the answer concrete.

Supported AI providers

Cognocient proxies all major providers through a single base_url configuration. No separate keys or SDK changes per provider.

See Supported Providers for SDK-specific configuration examples for each provider.

Security and privacy

Cognocient is built on a metadata-only logging principle:

• Prompt and response content is never stored. We log model, token counts, cost, latency, and your attribution headers — nothing else.
• Provider API keys are encrypted at rest using Fernet symmetric encryption. Keys are never logged or exposed in API responses.
• All traffic is encrypted in transit (TLS 1.2+).
• SOC 2 Type II audit is in progress. See Security & Privacy for the full control list.

Browse the documentation

How-to guides

Step-by-step walkthroughs for the most common tasks. Each is self-contained and takes under 30 minutes.

Frequently asked questions

How long does integration take?

Two minutes. Change your OpenAI base_url to api.cognocient.com/v1 and replace your API key with your Cognocient proxy key (sk-cog-...). All existing SDK calls continue to work unchanged — same method signatures, same response objects, same streaming behaviour.

Does Cognocient add latency to my API calls?

The proxy adds 10–30ms of overhead per call. Budget enforcement runs in Redis (sub-millisecond, not in the critical path). Semantic caching reduces latency for cache-hit requests — results return in under 10ms versus seconds for a live API call. For most production applications, the overhead is imperceptible.

Is my data secure?

Cognocient never stores prompt or response content. We log metadata only: model, token counts, cost, latency, and your attribution headers. Provider API keys are encrypted at rest using Fernet symmetric encryption. All traffic is encrypted in transit. SOC 2 Type II audit is in progress. See Security for the full control list.

What happens when my trial ends?

After 10 days, API calls return a 402 Payment Required error. No data is deleted. Upgrade to any paid plan to resume immediately. Your attribution history is retained for 30 days after trial expiry.

Can I use Cognocient with Anthropic, Google, or Mistral?

Yes. Cognocient proxies OpenAI, Anthropic, Google Gemini, Mistral, Groq, and Together AI. Use the same base_url for all providers. See Supported Providers for SDK-specific configuration examples.

How does budget enforcement actually work?

Cognocient checks your configured budget in Redis before every API call reaches the provider. If the budget is exceeded, the call is either blocked (returns 429), degraded (auto-switches to a cheaper model), or allowed with a webhook alert — your choice per budget rule. This is pre-call enforcement, not a billing alert 24 hours after the fact.

What is the "Investment vs. Waste" classification?

Every API call is classified as "Investment" (generating revenue, serving a user, improving a product) or "Waste" (over-engineered, redundant, inefficient, or purely exploratory) using a 3-tier heuristic engine. You can override classifications manually or train the classifier with feedback signals. The AI Investment ROI panel on the Engineering Dashboard shows this split live — investment protected, recoverable waste, efficiency score, and a one-sentence board summary. See Cost Intelligence for the full classification methodology.

Do I need to change anything in my Anthropic SDK calls?

Yes — the Anthropic SDK uses a different base URL option. See the Quickstart for the exact SDK configuration for Anthropic, Gemini, Mistral, and Groq. The pattern is the same: one base URL change, everything else stays identical.

Ready to start? Get started for free