Who uses Cognocient and how?

Engineering teams, FinOps leads, CFOs, and product managers all use Cognocient for different goals. Jump to the section that matches your role for a tailored setup checklist and the dashboard views most relevant to your workflow.

Jump to your use case: Customer Support Teams · Engineering Teams · Agentic AI Teams · FinOps & Finance · CFOs & Board Prep · SaaS Products · Legal & Compliance · Healthcare & Life Sciences · Managed Service Providers

Customer support teams

The situation: Consider a hypothetical SaaS company running an AI-powered support chatbot at meaningful ticket volume. The AI bill is one number on the invoice — and the VP of Support has no way to know whether that's good or bad. Is the AI actually cheaper than a human agent? Which ticket types cost the most? Is any of it going to tasks a template could handle for free?

Problem: Unknown cost per ticket — Tag every support session with the ticket ID using X-Cost-Session. Cognocient shows cost per session immediately, which you compare against your own known human-agent cost per ticket to get a real ROI figure — not a Cognocient-supplied benchmark, since that comparison depends entirely on your own support cost structure.

Problem: L1 vs L2 ticket cost difference — Tag tickets by tier using X-Cost-Feature: support-l1 and support-l2. If L1 tickets (password reset, FAQ) are costing noticeably more than L2 escalations, that's usually a sign a frontier model is being used where a cheaper one in the same family would do — see Token Maxing. A routing rule fixes it with no code change.

Problem: Month-end invoice surprise — Set a monthly budget on the support feature. When usage spikes (a new product launch, an incident), a forecast alert fires before the budget is projected to be breached, not after.

Problem: No visibility into waste — Context bloat detection flags sessions where conversation history is growing unbounded across long support threads. See Context Tax for how the static-vs-variable ratio is measured and what a caching fix looks like.

2-minute setup for customer support

Step 1 — Connect your support chatbot to Cognocient (30 seconds). Find the file where your support chatbot initialises the OpenAI (or Anthropic) client. Search your codebase for OpenAI( to find it.

# BEFORE — your current code
from openai import OpenAI
client = OpenAI(api_key="sk-proj-your-openai-key")
 
# AFTER — route through Cognocient (2 lines changed)
from openai import OpenAI
client = OpenAI(
    api_key="sk-cog-YOUR-PROXY-KEY",              # ← your Cognocient proxy key
    base_url="https://api.cognocient.com/v1"       # ← Cognocient's address
)
# Everything below this line stays EXACTLY the same

// BEFORE
const openai = new OpenAI({ apiKey: 'sk-proj-your-key' });
 
// AFTER
const openai = new OpenAI({
  apiKey: 'sk-cog-YOUR-PROXY-KEY',
  baseURL: 'https://api.cognocient.com/v1',
});

# BEFORE
import anthropic
client = anthropic.Anthropic(api_key="sk-ant-your-key")
 
# AFTER
import anthropic
client = anthropic.Anthropic(
    api_key="sk-cog-YOUR-PROXY-KEY",
    base_url="https://api.cognocient.com"
)

Step 2 — Add support-specific attribution headers (60 seconds). Find the place where the chatbot makes the actual API call and add extra_headers:

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=conversation_history,
    extra_headers={
        "X-Cost-Feature":    "support-chatbot",        # name of this feature
        "X-Cost-Department": "customer-success",        # your team name
        "X-Cost-Session":    str(ticket_id),            # the ticket or conversation ID
        "X-Cost-User":       str(customer_id),          # who is being helped
    }
)

const response = await openai.chat.completions.create({
  model: 'gpt-4o-mini',
  messages: conversationHistory,
}, {
  headers: {
    'X-Cost-Feature':    'support-chatbot',
    'X-Cost-Department': 'customer-success',
    'X-Cost-Session':    ticketId,
    'X-Cost-User':       customerId,
  }
});

Step 3 — Set a monthly budget for support (30 seconds):

1. Go to your Cognocient dashboard → Budgets → "New Budget"
2. Name: support-chatbot
3. Feature: support-chatbot (must match X-Cost-Feature exactly)
4. Monthly limit: your target spend
5. Enforcement mode: Degrade (switches to a cheaper model instead of stopping)
6. Click Create

After setup, your dashboard shows:

Engineering teams

The situation: Consider a hypothetical engineering team that has shipped several AI features over a quarter. The combined AI bill jumps one month. The CTO wants to know which feature caused the spike, whether it will keep growing, and whether any of the features are worth the cost. The engineering lead has no answer — the AI spend is one undifferentiated number on an invoice.

Problem: Unknown which feature caused a spend spike — Tag every API call with X-Cost-Feature. In the Feature Intelligence view, a spike attributes immediately to the specific feature driving it, rather than staying an unattributed line on the bill.

Problem: No way to evaluate AI feature ROI before shipping — Route a new model to a feature under a distinct feature tag before switching everyone over, so the cost difference is visible before it's committed to at full volume.

Problem: Multiple models used across features, no unified view — The Feature Intelligence view shows every feature, its model, and whether it's flagged for model mismatch or context bloat — one screen instead of reading logs feature by feature.

Problem: No budget enforcement in production — Set per-feature budgets in Degrade mode. If an eval harness is accidentally left running over a weekend, the feature switches to a cheaper model automatically rather than running unchecked until someone notices.

2-minute setup for engineering teams

Step 1 — Connect each AI feature to Cognocient (30 seconds per feature). For each file that calls an AI API, change the client setup. If your team uses a central AI client, change it there once and every feature is automatically connected.

# In feature_1/search.py
from openai import OpenAI
client = OpenAI(
    api_key="sk-cog-YOUR-PROXY-KEY",
    base_url="https://api.cognocient.com/v1"
)

Step 2 — Tag each feature with attribution headers (60 seconds):

# In search.py
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    extra_headers={
        "X-Cost-Feature":    "search",             # ← this feature's name
        "X-Cost-Department": "engineering",
    }
)
 
# In document_extractor.py
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    extra_headers={
        "X-Cost-Feature":    "document-extractor",  # ← different feature name
        "X-Cost-Department": "engineering",
    }
)
 
# In chatbot.py
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[...],
    extra_headers={
        "X-Cost-Feature":    "chatbot",
        "X-Cost-Department": "product",             # ← owned by product team
    }
)

Step 3 — Set one budget per feature (30 seconds each), starting in Alert mode for the first week to understand your baseline before switching to Degrade or Block for ongoing enforcement.

Agentic AI teams

The situation: Consider a hypothetical team building autonomous AI agents for document processing. One agent enters a loop, reprocessing the same document set repeatedly because its completion condition was never met. No alert fires, because no per-call check was ever going to catch a run-level problem — see Stopping a Runaway Agent for why per-call budgets structurally can't see this.

Problem: No cost visibility across multi-agent workflows — Use X-Cost-MCP-Server and X-Cost-Parent-Run-Id headers to build a full workflow cost tree. The Agent Workflows view shows parent agent → child tools → each tool's cost per invocation, so the expensive step in the pipeline is visible directly.

Problem: Runaway agent loops causing surprise bills — Set a per-run budget using X-Cost-Run-ID (one ID shared by every step in an agent run). Once the run's cumulative cost hits the ceiling, the next call is rejected — the run stops, it doesn't silently keep going.

Problem: Can't tell which tool calls are necessary vs. redundant — The Agent Workflows view shows every tool invocation with its cost, sortable descending. Semantic caching can eliminate duplicate tool calls that would have returned the same result.

Problem: No way to compare agent architectures by cost — Run two agent designs under different feature tags. The Feature Intelligence view shows cost and waste side by side for each — a data-driven comparison instead of a guess.

2-minute setup for agentic AI teams

Step 1 — Connect the agent's LLM client (30 seconds):

# LangChain
from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(
    model="gpt-4o",
    api_key="sk-cog-YOUR-PROXY-KEY",
    base_url="https://api.cognocient.com/v1",
    default_headers={
        "X-Cost-Feature":  "research-agent",
        "X-Cost-Workload": "agentic-read",
    }
)

# CrewAI
import os
os.environ["OPENAI_API_KEY"]  = "sk-cog-YOUR-PROXY-KEY"
os.environ["OPENAI_API_BASE"] = "https://api.cognocient.com/v1"
 
from crewai import Agent, Crew
agent = Agent(
    role="Research Analyst",
    llm="gpt-4o",
    # CrewAI uses the env vars automatically
)

# AutoGen
config_list = [{
    "model": "gpt-4o",
    "api_key": "sk-cog-YOUR-PROXY-KEY",
    "base_url": "https://api.cognocient.com/v1",
}]
assistant = autogen.AssistantAgent(
    "assistant",
    llm_config={"config_list": config_list}
)

# Direct OpenAI SDK (custom agents)
import uuid
 
client = OpenAI(
    api_key="sk-cog-YOUR-PROXY-KEY",
    base_url="https://api.cognocient.com/v1"
)
 
run_id = str(uuid.uuid4())  # unique ID for this agent execution
 
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    extra_headers={
        "X-Cost-Feature":  "research-agent",
        "X-Cost-Workload": "agentic-read",       # tells Cognocient this is an agent read op
        "X-Cost-Run-ID":   run_id,               # groups all steps in this run
    }
)

Step 2 — Set a per-run budget (30 seconds). Dashboard → Budgets → New Budget:

• Feature: research-agent
• Monthly limit: your target
• Per-run limit: the maximum you're willing to spend on a single agent execution
• Mode: Degrade for read-heavy agents, Block for anything performing a write operation

Step 3 — For multi-agent workflows, add parent tracking (optional):

# Agent A (the parent)
parent_run_id = str(uuid.uuid4())
response_a = client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    extra_headers={
        "X-Cost-Run-ID":   parent_run_id,
        "X-Cost-Feature":  "orchestrator",
        "X-Cost-Workload": "agentic-read",
    }
)
 
# Agent B (called by Agent A)
child_run_id = str(uuid.uuid4())
response_b = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[...],
    extra_headers={
        "X-Cost-Run-ID":         child_run_id,
        "X-Cost-Parent-Run-Id":  parent_run_id,   # ← links to parent
        "X-Cost-Feature":        "data-fetcher",
        "X-Cost-Workload":       "agentic-read",
    }
)

Your dashboard now shows a workflow tree: orchestrator → data-fetcher, with a cost at each node.

FinOps and finance teams

The situation: Consider a hypothetical FinOps lead responsible for AI cost governance across several departments. Month-end close is slow because department heads have to be emailed for usage estimates, the invoice has to be manually allocated, and a chargeback spreadsheet has to be rebuilt by hand every cycle. The board wants a monthly AI report, assembled manually.

Problem: Slow month-end close process — With department and GL headers set on every API key (a one-time setup), the Chargeback view shows real-time spend by department all cycle long. At month-end: Generate Report → FOCUS CSV → upload to ERP, instead of a multi-day manual reconciliation.

Problem: Manual board report assembly — Configure Scheduled Delivery to email the Executive View PDF automatically on a recurring cadence. Cognocient generates the AI-written narrative summary and charts — no manual assembly required. See Scheduled delivery.

Problem: No benchmark to tell if AI spend is improving — The AI Efficiency Score (cost per business outcome, trended month over month) is the metric Cognocient recommends tracking. A falling cost-per-outcome means the organisation is getting more value per dollar spent. See What Is an AI Efficiency Score? for exactly what it measures.

Problem: Departments pushing back on AI cost allocations — With per-call GL account attribution, every department sees a line-item audit trail of their own AI usage, tagged at the point of use rather than estimated after the fact.

2-minute setup for FinOps teams

Step 1 — Verify attribution is flowing (30 seconds). Log in to Cognocient → Dashboard → Overview. If calls are appearing with feature names and department labels, attribution is already working. If calls show "untagged," your engineering team needs to add X-Cost-Feature and X-Cost-Department headers.

Step 2 — Add GL account mapping (60 seconds). Ask your engineering team to add one more header to each feature:

extra_headers={
    "X-Cost-Feature":    "chatbot",
    "X-Cost-Department": "customer-success",
    "X-Cost-GL-Account": "5100-AI-SOFTWARE",     # ← your chart of accounts code
}

With GL account codes on every call, the monthly FOCUS export maps directly to your accounting system — see AI Spend Chargeback for the full header set and ERP import formats.

Step 3 — Set department-level budgets (30 seconds). Dashboard → Budgets → New Budget, one per department, in Alert mode to start.

Step 4 — Enable Scheduled Delivery (30 seconds). Dashboard → Reports → Scheduled Delivery: set a frequency, report type, and narrative tone, and add your recipients.

CFOs and board preparation

The situation: Consider a hypothetical CFO with a board meeting coming up where AI spend will be a topic. The board will ask: is it justified, what are we getting for it, is it under control, and what will it cost next quarter. The CFO currently has one total spend number and nothing else.

"Is it justified?" — The Outcomes view shows cost per outcome (per ticket resolved, per contract drafted, per document processed) that you compare against your own known cost for the same result — an ROI metric, not just a spend total.

"What are we getting for it?" — Investment vs. Waste classification splits spend into what's generating measurable value versus what's recoverable. The board summary sentence states both figures directly, in plain language.

"Is it under control?" — Budget enforcement prevents runaway spend structurally, not just via alerts. Anomaly detection surfaces spikes with a root-cause hypothesis attached. Together they make the governance story concrete rather than aspirational.

"What will it be next quarter?" — The Forecast view provides a 30/60/90-day spend projection with the underlying growth assumption stated explicitly, so the CFO can walk in with a projection and its basis, not a guess.

2-minute setup for CFOs

You do not need to write code. Your engineering team handles the technical integration — your setup is about configuring what you see.

Step 1 — Log in and open Executive View (30 seconds). Sign in → click "Executive View" in the sidebar.

Step 2 — Review unprotected features. The Executive View surfaces features with no budget set. For each one, click through to set a limit.

Step 3 — Generate your first board report (30 seconds). Click "Generate Report" on the Executive View. The PDF contains an AI-written executive summary, total spend with trend, top expensive features, waste identified, the AI Efficiency Score, and budget vs. actuals by department.

Step 4 — The numbers your board will actually ask about: total AI spend, the AI Efficiency Score trend (cost per outcome, up or down), and the waste percentage still recoverable.

SaaS products with AI features

The situation: Consider a hypothetical SaaS product that built AI features now showing up as a meaningful line item in per-seat cost — a feature meant to drive retention instead compressing margin. The team doesn't know which specific AI features are margin-negative versus margin-positive.

Problem: Unknown per-seat AI cost — Pass user IDs via X-Cost-User. The Users view shows cost per seat, which you can join against your own subscription data to find seats costing more in AI spend than their subscription price.

Problem: Not knowing which features drive AI margin — Feature Intelligence shows cost per feature per user, so a low-usage, high-cost feature is visible next to a high-usage, low-cost one on the same screen.

Problem: AI cost unpredictable as usage grows — The Forecast view projects AI cost at different growth scenarios, so a pricing decision can account for AI cost at scale before it's locked in, not after.

Legal and compliance teams

The situation: Consider a hypothetical corporate legal team using AI for contract review, first-draft generation, and matter research. Legal spend is subject to client billing and matter codes, so AI costs need to be allocated to specific client matters, not left as one shared invoice line.

Problem: AI cost not attributable to client matters — Pass the matter code as X-Cost-Department and client ID as X-Cost-Cost-Centre. Every AI call is attributed to the correct matter, and the month-end chargeback report shows AI cost per matter directly.

Problem: Partners can't see AI value — Outcome tracking shows cost per contract reviewed, which the practice can compare against its own known associate-hour cost for the same task.

Problem: Client cost thresholds — Set per-matter budgets (keyed on the matter code). A forecast alert fires as a matter's AI spend approaches its client-approved threshold, before the client would ever see it.

Healthcare and life sciences

The situation: Consider a hypothetical health-tech company using AI for clinical documentation, patient communication, and prior authorisation processing. Regulatory requirements demand an audit trail; finance needs per-product-line AI cost allocation; compliance needs assurance that no patient data passes through AI provider infrastructure via Cognocient itself.

Problem: No audit trail for AI usage — Every API call is logged with timestamp, model, token count, feature, and trace ID. Call logs are exportable — a usage audit trail without capturing patient data, since Cognocient never reads or stores prompt or response content. See Security & Privacy.

Problem: Per-product-line cost allocation — Tag calls by product line using X-Cost-Department. Clinical Documentation, Patient Communication, and Prior Auth each get a separate, automatic spend line.

Problem: Cost per clinical document justification — Outcome tracking shows AI cost per document or per prior-authorization processed, which you compare against your own known manual-processing cost for the budget committee.

Managed service providers (MSPs) and agencies

The situation: Consider a hypothetical AI services agency managing AI infrastructure for multiple enterprise clients on a consolidated provider invoice. The agency needs to chargeback accurately per client and demonstrate the value of its managed service with real data, not an assertion.

Problem: Consolidated invoice, many clients to allocate to — One Cognocient proxy key per client, with the client ID as the default department. The Chargeback view shows per-client spend, and a Line-item Detail PDF per client is ready for inclusion in invoices at month-end.

Problem: Proving the value of managed services — Show each client their own cost-per-outcome trend over time under your management — a concrete number instead of a claim, drawn from their own data.

Problem: Client AI spend growing unexpectedly — Set per-client budgets. Anomaly alerts fire to the agency account before the client notices a spike, so the agency can investigate and resolve proactively.

Frequently asked questions