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: A SaaS company runs an AI-powered support chatbot handling 28,500 tickets per month. The AI bill is $12,000/month — and the VP of Support has no idea whether that's good or bad. Is the AI actually cheaper than human agents? Which ticket types cost the most? Are there any tickets where the AI is being used for something a template could handle?

Problem: Unknown cost per ticket — Tag every support session with the ticket ID using X-Cost-Session. Cognocient immediately shows cost per session — $0.42/ticket — which you compare against your human agent cost of $8.40. The ROI is now provable.

Problem: L1 vs L2 ticket cost difference — Tag tickets by tier using X-Cost-Feature: "support-l1" and "support-l2". L1 tickets (password reset, FAQ) should cost under $0.20 — if they're costing $1.80, you're using GPT-4o when GPT-4o-mini would do. One routing rule fixes it in 2 minutes.

Problem: Month-end invoice surprise — Set a monthly budget on the support feature. When usage spikes (new product launch, incident), you get a forecast alert 7 days before the budget is breached — time to scale the budget or optimise.

Problem: No visibility into waste — Context bloat detection flags sessions where conversation history is growing unbounded. A 20-turn support session can waste $0.30/session on tokens that carry no signal. Cognocient's recommendation: implement a rolling context window of 8 turns.

Typical result after 30 days: $0.42 cost per ticket (was $0.74) · 43% reduction in support AI spend · 20× cheaper than human L1 agents

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 (e.g., $5,000)
5. Enforcement mode: Degrade (switches to a cheaper model instead of stopping)
6. Click Create

After setup, your dashboard shows:

Engineering teams

The situation: An engineering team has shipped 6 AI features in the past quarter. The combined AI bill jumped 40% last month. The CTO wants to know which feature caused the spike, whether the bill will continue growing, and whether any of the features are worth the cost. The engineering lead has no answers — the AI spend is one undifferentiated number.

Problem: Unknown which feature caused the 40% spike — Tag every API call with X-Cost-Feature. In the Feature Intelligence view, the spike is immediately attributed to document-extractor, which grew 182% after the v2.1 deployment. Root cause: prompts are 47% longer in v2.1.

Problem: No way to evaluate AI feature ROI before shipping — Use shadow routing to test a new model on a feature before switching — see the quality comparison and cost difference before committing. Kill or change course before the feature ships at the wrong cost point.

Problem: Multiple models used across features, no unified view — The Feature Intelligence view shows every feature, its model, and its efficiency score. A single screen tells the CTO: "We're using GPT-4o for 3 features that should be on mini. Here's the monthly saving."

Problem: No budget enforcement in production — Set per-feature budgets in Degrade mode. If a feature's eval harness is accidentally left running over a weekend, it switches to a cheaper model rather than running up a $2,000 bill by Monday morning.

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):

Start with Alert mode for the first week to understand your baseline, then switch to Degrade for ongoing enforcement.

Agentic AI teams

The situation: A team building autonomous AI agents for document processing woke up to a $4,200 bill for a single weekend. One agent had entered a loop, processing the same document set repeatedly because the completion condition wasn't met. No alerts fired. No one knew. They found out on Monday morning when the invoice arrived.

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 MCP Attribution view shows: parent agent → child tools → each tool's cost per invocation. Know exactly which step in your pipeline is the expensive one.

Problem: Runaway agent loops causing surprise bills — Set a per-run budget using X-Cost-Session (one ID per agent run). When the run's cumulative cost hits the budget, Cognocient switches to Degrade mode — the agent continues working but on cheaper models. No hard stop. No Monday morning surprise.

Problem: Can't tell which tool calls are necessary vs redundant — The Agent Workflows view shows every tool invocation with cost. Sort by cost descending — the most expensive tool calls are visible immediately. Semantic caching can eliminate duplicate tool calls that return the same result.

Problem: No way to compare agent architectures by cost — Run two agent designs under different feature names. The Feature Intelligence view shows side-by-side cost-per-run and waste% for each design — data-driven architecture decisions instead of guesswork.

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",
    }
)

# 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",            # tells Cognocient this is an agent
        "X-Cost-Run-ID":   run_id,               # groups all steps in this run
        "X-Cost-Session":  run_id,               # same as run_id for cost-per-run
    }
)

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

• Feature: research-agent
• Monthly limit: $2,000
• Per-run limit: $5.00 (maximum cost for a single agent execution)
• Mode: Degrade

Now if any single agent run exceeds $5.00, it switches to a cheaper model instead of running indefinitely. Your $4,200 Monday surprise becomes a $5 capped run that still completes.

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",
    }
)
 
# 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",
    }
)

Your dashboard now shows a workflow tree: orchestrator ($1.20) → data-fetcher ($0.40) → total: $1.60

FinOps and finance teams

The situation: A FinOps lead at a 400-person company is responsible for AI cost governance. Five departments use AI. Month-end close takes 3 days because she has to email each department head to estimate their AI usage, reconcile the numbers, manually allocate the invoice, and build the chargeback spreadsheet. The board wants a monthly AI efficiency report. She's been building it manually for four months and it takes Sunday evenings.

Problem: 3-day month-end close process — With department headers set on every API key (a one-time setup), the Chargeback view shows real-time spend by department. On the last day of the month, click Generate Report → FOCUS CSV → upload to ERP. Close in 15 minutes, not 3 days.

Problem: Manual Sunday evening board report — Configure the Executive View PDF to deliver automatically on the 1st of each month to the CFO and board secretary's email. Cognocient generates the AI-written narrative summary, charts, and efficiency score. No Sunday assembly required.

Problem: No benchmark to tell if AI spend is improving — The AI Efficiency Score (0–100) is the single metric Cognocient recommends tracking as a FinOps KPI. A score trending upward means your organisation is getting more value per dollar spent on AI. Show the 6-month trend at the board.

Problem: Departments pushing back on AI cost allocations — With per-call GL account attribution, every department sees a precise line-item audit trail of their AI usage. No estimates, no disputes. The data is irrefutable because it was tagged at the point of use.

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. No manual reconciliation. Upload the CSV to NetSuite / QuickBooks / Xero and the chargeback is done.

Step 3 — Set department-level budgets (30 seconds). Dashboard → Budgets → New Budget:

• Name: customer-success-monthly
• Department: customer-success (matches X-Cost-Department)
• Monthly limit: $5,000
• Mode: Alert (sends notification at 80% and 100%)

Create one budget per department. The Executive View then shows Budget vs Actuals for every department automatically.

Step 4 — Schedule the monthly report (30 seconds). Dashboard → Reports → Schedule:

• Frequency: Monthly (1st of each month)
• Recipients: cfo@company.com, finops-lead@company.com
• Format: PDF (includes AI-written narrative + charts + efficiency score)

CFOs and board preparation

The situation: A CFO has a board meeting in 6 weeks. The board will ask about AI spend — it has tripled in 18 months. The CFO needs to answer: Is it justified? What are we getting for it? Is it under control? What will it be next quarter? She has a total spend number and nothing else.

"Is it justified?" — The Outcomes view shows cost per ticket ($0.42 vs $8.40 human cost), cost per contract ($2.10 vs $200 lawyer time), cost per document processed ($0.08 vs $2.50 manual). The board gets ROI metrics, not just a cost number.

"What are we getting for it?" — Feature Intelligence classifies 68% of spend as Investment (features delivering measurable business outcomes) and 12% as Waste (recoverable). The CFO can say: "We've identified $2,400/month in recoverable waste and are actively addressing it."

"Is it under control?" — The AI Efficiency Score of 84/100, up 14 points in 6 months, demonstrates active management. Budget enforcement prevents runaway spend. Anomaly detection catches spikes within 5 minutes. The governance story is compelling.

"What will it be next quarter?" — The Forecast view provides a P25–P75 confidence range with assumptions stated explicitly. Three scenarios (conservative, expected, high-growth) are modelled and exportable as a PDF. The CFO walks in with projections, 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). Go to cognocient.com → Sign in → click "Executive View" in the sidebar. Three sections: This Month — total AI spend with trend; Governance — which features have budgets and which don't; Recommendations — where money can be saved.

Step 2 — Review the Governance panel (30 seconds). The Governance panel shows protected features (with budgets) and unprotected features (spending money with no limit). For each unprotected feature, click "Set budget →" to add a limit.

Step 3 — Generate your first board report (30 seconds). Click "Generate AI Report →" on the Executive View. Wait 15–20 seconds. The PDF contains:

• AI-written executive summary (written by Claude, not a template)
• Total spend with month-over-month trend
• Top 5 most expensive features
• Waste identified and recovered
• AI Efficiency Score (0–100)
• Budget vs Actuals by department

Step 4 — The three numbers your board wants:

1. Total AI spend — Top of Executive View
2. AI Efficiency Score — 0–100, trending up = improving
3. Waste rate — % of spend that is recoverable

SaaS products with AI features

The situation: A SaaS product charges $150/seat/month. They built AI features that are now costing $18/seat/month in AI API fees — eating 12% of revenue on a feature that was supposed to drive retention, not compress margin. They don't know which specific AI features are margin-negative vs. margin-positive.

Problem: Unknown per-seat AI cost — Pass user IDs via X-Cost-User. The Users view immediately shows cost per seat per month. Join against subscription data to find margin-negative seats — users costing more in AI than their seat price. Typical finding: 8% of users account for 31% of AI cost.

Problem: Not knowing which features drive AI margin — Feature Intelligence shows cost per feature per user. The "smart email drafting" feature costs $0.12/user/month (high value, used by 70% of seats). The "AI image caption" feature costs $3.40/user/month (low usage, niche value). Easy decision.

Problem: AI cost unpredictable as usage grows — The Forecast view projects AI cost at different growth scenarios. Before a pricing decision, model what AI costs look like at 2×, 5×, and 10× current scale. Bake the AI cost margin into your pricing model with confidence.

Legal and compliance teams

The situation: A corporate legal team has deployed AI for contract review, first-draft generation, and matter research. Legal spend is subject to client billing and strict matter codes. The team needs to allocate AI costs to specific client matters for billing, demonstrate AI efficiency to senior partners, and ensure AI spend is compliant with client cost approval thresholds.

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. Month-end chargeback report shows exact AI cost per matter — ready for client billing.

Problem: Partners can't see AI value — Outcome tracking shows cost per contract reviewed ($1.80) vs. senior associate time ($180/hour for 2 hours = $360). The AI Advisor generates a quarterly efficiency report showing AI savings by matter type.

Problem: Client cost thresholds — Set per-matter budgets (keyed on the matter code/department). When a matter's AI spend approaches the client-approved threshold, a forecast alert fires — the team knows before the client does.

Healthcare and life sciences

The situation: A health-tech company uses AI for clinical documentation, patient communication, and prior authorisation processing. Regulatory requirements demand audit trails. Finance needs per-product-line AI cost allocation. The compliance team needs to know that no patient data passes through AI provider infrastructure.

Problem: No audit trail for AI usage — Every API call logged with timestamp, model, token count, feature, and trace ID. Call logs are immutable and exportable — a complete audit trail without capturing patient data (Cognocient never reads prompt content).

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

Problem: Cost per clinical document justification — Outcome tracking shows AI cost per prior auth processed ($0.31) vs. manual processing ($12.00). The 38× efficiency gain is documented and ready for CMS or budget committee presentations.

Managed service providers (MSPs) and agencies

The situation: An AI services agency manages AI infrastructure for 12 enterprise clients. They pay a consolidated AI provider invoice and need to chargeback accurately to each client. They also need to demonstrate the value of their managed service through efficiency improvements — but have no data to show.

Problem: Consolidated invoice, 12 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. Generate a Line-item Detail PDF per client at month-end. Include in client invoices.

Problem: Proving the value of managed services — Show each client their AI Efficiency Score trend. A score that went from 58 to 82 in 6 months under your management is a compelling proof-of-value that justifies the management fee and reduces churn.

Problem: Client AI spend growing unexpectedly — Set per-client budgets. Anomaly alerts fire to the agency account before the client sees a spike — the agency can investigate and resolve before the client calls. Proactive service that differentiates from DIY.

Next steps: Quickstart — 2 min setup · Chargeback · Outcomes