Karan Vijayakumar
Tokyo, Japan
Leading Cogent ⍺Building Cogent α.
Staff AI Engineer · Engineering Lead, Cogent ⍺
At 25, I lead the technology behind Cogent ⍺, Cogent Labs' AI-native brand, a managed AI service that automates document processing end to end. The title is Staff AI Engineer; the remit is the whole technical side: architecture and technical strategy, the roadmap and the engineering team, with the final call on technical decisions and a seat alongside the company's leadership. Underneath it all is SRE and platform engineering at scale, most of it written in Rust.
Intern to engineering lead in four years
- 2022 SRE Intern
- 2023 SRE
- 2024 Senior SRE
- 2026 Senior Platform Engineer
- 2026 Engineering Lead
- LeetCode Guardian · top 0.02%
- CodeChef 5★ · top 0.5%
- HackerRank 6★ gold · top 1% AI
- Advent of Code Global #2, day 15
Based in
Tokyo東京
35.6762° N
139.6503° E
Fleet Power
10 MW
accelerator fleet
Throughput
100K+ req/s
Rust gRPC gateway, sub-ms overhead
Telemetry Ingest
2 TB/hr
self-hosted LGTM pipeline
Uptime
99.99%
98% compute utilization
Experience
Five years of production.
012026–Now
Cogent Labs
Staff AI Engineer
Technical lead of Cogent ⍺, Cogent Labs' AI-native brand: architecture and technical strategy, the roadmap and the engineering team, working directly with the company's leadership. Promoted from Senior Platform Engineer in October 2026.
022026
Cogent Labs
Sr. Platform Engineer
Reliability tooling for a 10 MW accelerator fleet: DCGM health checks surfacing Xid/ECC and NVLink faults, with a controller that cordons, drains and recycles degraded nodes before they corrupt inference. Led a lights-out GitOps rewrite: Terraform owns the AWS estate, Argo CD reconciles rollouts with SLO-gated rollback.
032024–2026
Sales Marker
Sr. Site Reliability Engineer
A 2000+ vCPU hybrid Kubernetes estate. Rust/Tokio gRPC gateway at 100K+ req/s with sub-millisecond overhead, a Prometheus-to-Karpenter control loop holding 99.99% uptime at 98% utilization, and a self-hosted LGTM stack ingesting 2+ TB/hour after migrating off Datadog.
042024
Rapyuta Robotics
SRE / InfraOps
GKE platform with ArgoCD GitOps and a service mesh for traffic and observability. Built a Rust eBPF agent on Aya capturing kernel-level scheduling, disk and socket metrics across a robot fleet at under 1% CPU overhead.
052022–2024
FourKites
Site Reliability Engineer
Rust rate-limiting service at 100K req/s over gRPC, a layer-4 router with automated failover, and Prometheus exporters processing 50K+ metrics/second. Took system-wide API protection to five nines.
Stack
Tools I reach for.
Rationale
Each one is load-bearing somewhere. Pick a tool and I’ll tell you where.
Rust
Almost every control loop I own is Rust: the Tonic gateway at 100K+ req/s with sub-millisecond overhead, the Karpenter scheduler, the eBPF agent. If it sits in the path of every request, I want the compiler arguing with me before production does.
Go
The Kubernetes ecosystem speaks Go, so anything that has to talk to client-go natively, or be maintained by the next person on call, gets written in it. It wins on gravity more than on merit, and I miss Rust enums every time.
Python
Glue, analysis, and anything touching the ML side: DCGM scrapes, telemetry spelunking in a notebook, the occasional DAG. I like it right up to the moment it becomes a service someone has to be paged for.
TypeScript
Anything with a browser attached, this site included. Types are the only reason I trust frontend code I wrote six months ago, and internal dashboards always outlive the incident that prompted them.
Kubernetes
The substrate under everything I run, from a 2000+ vCPU hybrid estate to a 10 MW accelerator fleet. The API is the real product: once cordon and drain are objects I can reconcile, self-healing stops being a script and becomes a controller.
Terraform
Terraform owns the AWS estate down to the IRSA bindings, in reusable modules with drift detection. Not because HCL is pleasant, but because a plan diff is the cheapest possible argument about a change to a VPC.
Argo CD
Continuous reconciliation with SLO-gated auto-rollback is what let us take production access away from humans entirely. App-of-Apps for structure, sync waves for ordering, and sync status as the honest answer to what is actually running.
Helm
A packaging format I use carefully rather than fondly. Library charts with values.schema.json validation and shared templates for RBAC, network policy, and OTel sidecars ended the chart sprawl; without that discipline templated YAML rots fast.
Docker
The boring, correct boundary. Build once, sign with Cosign, generate an SBOM, scan with Grype, and let Kyverno refuse anything unsigned at admission. The image is the only place supply-chain policy has something to grab.
AWS
Where most of the estate lives: EKS, RDS, MSK, and the IAM wiring underneath. I have no loyalty to the brand, only to knowing which quota bites first at fleet scale, which is most of the actual skill.
GCP
GKE and a service mesh across a robot fleet at Rapyuta. Node pools and mesh traffic controls fought me less than the equivalents elsewhere, and Cloud Operations was a fair anomaly-detection backstop before I had my own.
Linux
Everything under the abstraction. Cgroups, scheduler latency, socket queues, NUMA placement on GPU nodes. When a pod is merely “slow”, the answer is almost always a kernel detail someone hoped never to have to read.
Prometheus
The scrape-and-query model is simple enough to build against: a Rust control loop reads its own SLIs from Prometheus and drives Karpenter. Recording rules and a cardinality budget are not optional; that is where the cost hides.
Grafana
Where on-call actually looks at 3 a.m., so I treat a dashboard as an interface, not a dump. Ten panels tied to SLOs beat forty nobody reads, and one pane over Loki, Tempo, and Mimir is what made leaving Datadog survivable.
Loki
Log volume is the line item that made Datadog untenable. Loki indexes labels instead of contents, so I pay for storage rather than for indexing. The trade is that sloppy labels turn queries into full scans.
Tempo
Traces are the only thing that answers which hop ate the latency once a mesh is involved, and Tempo is cheap enough to keep a useful sampling rate. A Prometheus exemplar straight into a span is the fastest path from symptom to cause I have.
Mimir
Long-term metrics at 2+ TB/hour without retention turning into a budget meeting. Horizontally sharded and multi-tenant, so per-team limits are something the system enforces instead of something I have to email about.
OpenTelemetry
One instrumentation standard so the backend stays replaceable: it's why the Datadog migration was a collector config change rather than a rewrite in every service. SDK churn is irritating; being locked to a vendor is worse.
eBPF
Kernel-level truth without a kernel module. My agent on Aya captured scheduling latency, disk I/O, and socket metrics across a robot fleet at under 1% CPU. When userspace swears the service is healthy and it plainly is not, this says why.
Writing
Notes on infrastructure.
- 01
Your autoscaler is a 300 GB file copy
Picking a better autoscaling signal for GPU inference is polishing the wrong dial: the loop's response time is dominated by getting weights into HBM, so the controller cannot catch the incident that triggered it. A timed breakdown of where scale-up time actually goes on a 10 MW fleet, why this contradicts what I wrote about headroom and placeholder pods, and the warm-pool arithmetic I landed on instead.
2026 16 min - 02
Argo CD config management plugins: the escape hatch I keep reaching for
Notes from wiring CMP sidecars into a GPU fleet rollout: what plugin.yaml actually does, a SOPS plugin and a CUE plugin that earn their keep, and the ways all of this bites in production.
2026 11 min - 03
Five nines is a boring number
Five nines is 5.26 minutes of downtime a year, which rules out heroics by arithmetic. Looking back two years later at what actually moved the number, what only looked like reliability work, and why almost all of it came from changing client behavior rather than adding capacity.
2026 9 min
Contact