GPU evidence for on-premise and sovereign AI clusters

Your GPU dashboard is lying to you.

On our own run the gauge read 100% utilisation and could not say how much useful work the GPU did. Cognit reads your cluster from the scheduler down to the hardware, attributes GPU-hours to the tenant and job that used them, and seals the record in a tamper-evident chain — continuous evidence of what your GPUs delivered, for the operator, the tenant and the auditor. Read-only. Deployed on your own infrastructure.

Book a scoping study See how it works
Read-onlyOn your infrastructureBuilt in India
Measured · our lab 100% utilisation · ~5.4% token-MFU The gauge read 100% and could not say whether the work was useful. L40S, Qwen2.5-14B-AWQ on vLLM, 32 concurrent streams, 15 Jun 2026. Token-throughput estimate against the dense BF16 peak; 2.7% against the sparsity peak. A decode-heavy run is memory-bandwidth-bound, so single-digit MFU is the physics ceiling here, not proof of waste — the point is that the gauge cannot tell you which.
Measured · our lab 15.8 W at the driver · 142 W at the node rail The same idle node, read the same minute: the GPU's own draw against what the whole node drew at the rail. The driver answers a narrower question than the one the invoice asks. NVML per-device power against the node's DCMI rail via /sys/class/hwmon. Two different quantities by design. Single node, idle, 10 Aug 2026.
Measured · customer, France 7 of 11 GPUs idle at this read First snapshots of a customer's 11×RTX 4090 inference fleet, June 2026: seven GPUs idle and four holding loaded models at near-zero utilisation, on a box the dashboards called healthy. Published with the customer's written permission. One read, not a fleet statistic.
01 · Why

Five ways the dashboard lies.

The numbers most clusters run on were built to say whether a GPU is on. They don't say who used it, whether the work was useful, or whether you got what you paid for.

Busy is not productive"Utilisation" counts time a kernel was running, not how much of the chip it used. MFU — model-FLOP utilisation — does. We compute it and say exactly how.
Idle-looking is not idleA protein-folding job at 20% can be waiting on storage. Reclaim that GPU and you kill a working run. Kernel io-wait tells idle apart from storage-starved.
GPU power is not node powerThe driver reports the accelerator alone. Your bill, your PUE return and your energy report are all the node — CPU, memory, fans, drives and supply losses included.
Shared GPUs lose the nameOnce usage is averaged, the tenant or team behind it is gone. We attribute before anything is aggregated, from the kernel's own process table.
Billed is not deliveredA tenant pays for a GPU-hour. Nothing in the standard stack signs what that hour actually produced, or whether the GPU was degraded while it was billed. We attribute, check and seal the record before anyone aggregates it.
02 · How it works

Five steps from raw telemetry to evidence an auditor can re-derive.

1 · CollectReads the scheduler, the GPUs, the kernel's process table and the driver, and the board management controller. Can start from the Prometheus you already run.
2 · AttributeTies every GPU-hour and byte of memory to a tenant, job and process. Node power is measured at the rail; per-job energy is modelled, and labelled as such.
3 · CheckRuns fixed rules for waste, faults and compliance controls. A rule it can't assess says so.
4 · SignSeals each finding into a hash-chained, tamper-evident log under a key the operator holds. Change one entry and every later link breaks.
5 · VerifyAn auditor can read the rule, read the evidence, and re-derive the verdict by hand. A finding without its evidence attached is treated as a bug.

No AI model decides a finding. Every verdict carries the rule that produced it and the evidence it read. A language model only writes the plain-English explanation — and can be switched off entirely, with the findings unchanged.

03 · Proof

What it has already caught, and who is using it.

Each result is dated and from a real machine — a customer's fleet or our own reference cluster; one is the customer's own statement. Ask for the long version on a call.

Field results

Jun 20267 of 11 GPUs idle at this read — first snapshots of a customer's 11×RTX 4090 fleet in France; four more holding loaded models at near-zero utilisation.
Jul 2026A training run spotted the moment it started on GPUs 4–7 of the same fleet, with no configuration, while inference findings kept firing on GPUs 0–3. The operator didn't tell us; the kernel did.
Jul 2026A node flagged itself at 79°C while we were recording a customer demo. Unscripted, surfaced before anyone asked.
Aug 20268,356 MiB of GPU memory held at 0% utilisation on our own reference cluster, with the holding process named from the kernel's file-descriptor table.
Sep 2026Five custom Prometheus gauges from a distributed training run, added by the customer's engineer, picked up with no changes on our side. Customer-stated.

Five design partners

An inference provider in FranceLicensed deployment11×RTX 4090, three production vLLM endpoints, running Cognit since June 2026. He has corrected our detection rules from his own physics — twice. We publish the corrections.
"It is on-premise with no outbound telemetry, which is not optional for a company like us selling data sovereignty. And it runs read-only against our inference GPUs, so adopting it never put production at risk."Co-founder of the inference provider above · 11 September 2026 · quoted with written permission
Robotics simulation engineerPaidTwo paid milestones delivered. His field report handed us seven real failure modes, with crash signatures, that standard monitoring stacks miss today.
A quant, a GPU-optimisation firm, an edge-AI engineerIn progressTesting our attribution against their own measurements — an adversarial user by profession, a profiling practice with ground truth, and the same evidence layer on ARM boards.

Partners are named when they say so, not before.

04 · Who it's for

One sealed record. Two sides of the GPU-hour.

Whoever sells the capacity and whoever pays for it are looking at the same hour from opposite ends. Today the only record of it is a utilisation gauge neither side can take to a dispute.

If you sell GPU capacity Prove what you delivered. Neoclouds and sovereign operators, GPU rental and colocation providers: show each tenant what they received, per job, in a sealed record you can put in front of them.
  • Per-tenant, per-job attribution that survives aggregation, from the kernel's own process table
  • Degraded-while-billed intervals flagged from the node itself: XID and ECC errors, thermal throttling, a node that dropped out
  • One record for tenant disputes, SLA conversations, tenders and audits — continuous risk monitoring, kept inside the country
If you own or run GPUs Prove you got what you paid for. Enterprise AI teams, research platforms and regulated R&D: continuous evidence of goodput, and clean evidence when an hour was not what you were billed for.
  • Continuous evidence of goodput: what each GPU did against what it could have done, with the health events alongside, not just a busy gauge
  • Clean evidence for any SLA-credit claim: the dated record of when a GPU was degraded or unavailable, which job was on it, and what it produced — what a provider's claims process asks for and nobody has
  • Audit readiness check for IT operations; an assessment with fewer stakeholder interactions for your auditors; GxP, DPDP Act, ISO 27001 and SOC 2 (TSC mapping) evidence from the same trail, for the controls it can sense

If you sell the platforms or hardware these clusters run on, Cognit reads what your products already expose — DCGM, Redfish, Prometheus, Slurm, Kubernetes — as a read-only component beside your stack. Talk to us about integration and referral.

Today Cognit produces this record on clusters you run. Acceptance tests run as a tenant on public GPU clouds are in development. Not a fit if you only call hosted model APIs, run a single workstation, or use fully managed serverless GPUs.

05 · Product

Two editions. Start with one, add the other.

Both run agentless from the metrics you already export, or with our on-premise agent for process-level attribution from the kernel's process table and the driver, plus board-level hardware detail. Kernel tracing runs in our lab.

ObserveSee what every GPU is really doing, and who is doing it.
  • GPU time and memory attributed per tenant and job; node power measured at the rail, per-job energy modelled and labelled
  • Idle and stranded capacity, with the holding process named
  • Workload identity: "python3" becomes the actual tool — 14 signatures, 6 verified firing on live runs
  • Hardware faults and thermal warnings read from the node itself
Govern includes ObserveTurn what you see into evidence built for an auditor to re-derive.
  • Control catalogue across 40 frameworks; 27 backed by live evidence today, the rest say "not assessed"
  • Hash-chained, tamper-evident audit log
  • Gaps ranked by how many controls each fix closes, with the remediation step
  • Policy enforcement In development
06 · Pricing

Start small. Every step is credited to the next.

Fixed scope, fixed price, invoiced on delivery. Nothing is installed for the first step.

Step 1 · two weeksScoping study₹2,50,000You export the counters, scheduler logs and power readings for one cluster or node; we attribute by hand. You get the idle-GPU list with hours, its value at your own rate card, the decisions it supports, and a sample sealed record. Credited in full against step 2.
Step 2 · read-only pilotProof of audit₹8,50,000Cognit on your cluster, read-only, producing sealed findings and the artefact your auditor actually reads. Scoped to your estate. Creditable in full against year one.
Step 3 · scoped per engagementFull audit and licenceScopedThe full control catalogue across your estate, ending in an auditor work paper, and the ongoing licence — priced against what the audit found, not from a table.

INR prices exclude 18% GST. Formal quotations are issued in INR; a quotation in SGD, EUR or USD is available on request.

07 · Our method

We label what we know, and how we know it.

MeasuredRead from a sensor, counter or log on the machine, with the source named.
ModelledEstimated from measured inputs. Today that includes our energy and inference panels.
Not assessedShown, never hidden, when we lack the data to judge a control. On a first engagement most controls start here.
Want to see what an auditor would receive? Ask for a walkthrough of a sealed record from our reference cluster.Ask for a walkthrough
08 · Company

Built in India, by people who run GPUs.

Cognit is built by Megh Communications, a self-funded infrastructure company: a lab cluster the product is developed against, a Rust agent, and the carrier boards and node telemetry our evidence will one day start from — board revisions are in the lab. Registered in Kerala; lab in Bengaluru.

9telemetry layers read, job to hardware
255probes execute across 1,383 catalogue controls; 27 of 40 frameworks carry live evidence
117BMC sensors read on the lab reference node, timestamped per sensor
66defensible detection patterns, of 111 in the catalogue
14workload signatures; 6 verified firing on live runs
8,700automated tests, plus 1,100 mutation checks — each a deliberately broken line the tests must catch

Under it: a Rust agent that reads the kernel's process table and the driver and runs as a process-only DaemonSet or a host unit; a Python engine and console; PostgreSQL for the audit chain; nginx as the only network door. The language model is optional and never decides a finding. Counts measured on the main branch, October 2026.

The engineers

Co-founder · productSandeep KrishnaNetwork and systems engineering; previously Telstra and Ericsson. Leads the product and the lab.
Rust systems & performanceBobby MathewsSystems and performance engineering in Rust: executor starvation, tail latency, backpressure and lock-free real-time paths. Publishes original benchmark research, including a measured 101× p99 scheduling-overhead increase when blocking work saturates an async runtime. GPU-accelerated processing of high-frequency sensor data; compute and shader tooling over Vulkan and WebGPU.
Lab clusterSainath ReddyRuns the lab cluster the product is developed against. FPGA and VLSI background.
Hardware verificationSaheb MandalCOM-HPC carrier design verification: power stage, eFuse telemetry and PMBus.
Carrier boardAgnidipa MannaDesigns the COM-HPC carrier board, the indigenous compute module.
Linux systemsEbin BabuLinux systems engineering.
Robotics · ROS2Truong N.Isaac Sim and Isaac Lab on scheduler-managed clusters. Ran the RT-core experiment.
Forward deploymentSavin SundarPMP, PMI-ACP and CSM. Led multi-country programmes across India and Africa to on-site go-live.

The company

FounderKrishnadas PuthukudyCapital, operations and strategy. Heads the services business that funds the build; previously Saudi Chevron.
StrategyParag SomaniTechnology investment banker and former founder.
OperationsYoshita PacholyProject delivery and programme management; previously Xieno, Ericsson.
GrowthKajal J.Six years in B2B sales and go-to-market across APAC and EMEA; outbound and qualification for an AI-observability platform.

Also advising on audit and compliance: Shruthi P Nair — reviews the work-paper format against how an auditor actually reads it.

09 · Contact

See your cluster as it actually is.

Tell us about your cluster. We reply within two business days with a scoping proposal.

sales@cognit.run