Skip to main content

Stop Rewriting Your AI Video Integrations Every Time You Switch Providers

· 7 min read
Aman Kumar Singh
Aman Kumar Singh
Software Engineer Intern
TL;DR:

Every AI video provider has its own SDK, its own parameter names, its own polling logic. Tarash Gateway gives you one interface for all of them. Switch providers with a config change, chain them together, and never rewrite an integration again.

The AI video model space moves fast. Every few weeks there's a new model worth trying: better motion, better prompt adherence, better pricing. So we tried them all.

Every switch meant the same work: different SDK, different parameter names, different polling logic, different error format. duration_seconds on one provider, duration on another, an enum string on a third. Each integration took a day. Each one was slightly different from the last in ways that didn't matter but had to be handled anyway.

And when a provider went down, the pipeline went with it. No fallback, no graceful degradation. Just errors until someone manually switched.

We weren't solving a new problem each time. So we built Tarash Gateway. We're Vertexcover, and we build tooling for teams working with AI-generated video.

Building SceneFlow: The Intelligent Video Cutter

· 9 min read
Aman Kumar Singh
Aman Kumar Singh
Software Engineer Intern
TL;DR:

SceneFlow isn't just a video cutter, it's an intelligent editor. By combining signal processing with Multimodal AI, it finds the perfect cut points, ensuring your videos never end with awkward freezes, mid-sentence chops, or blinking eyes.

If you've ever worked with AI-generated videos, you know the problem. The content is great, but the endings are... weird. The avatar freezes, stares blankly into the soul of the viewer, or cuts off mid-breath.

Notice the awkward movement of the subject at the end of this AI-generated video

To make these videos production-ready, you have to manually trim that awkward tail. For one video, it's fine. For 1,000 personalized outreach videos? It's a nightmare.

We wanted to automate this. But simple tools like ffmpeg or basic silence detectors aren't enough. They don't "see" the video. They don't know if an avatar's face looks unnatural.

So we built SceneFlow.

Why Node.js and Python Don't Use Linux's Native Async I/O API

· 11 min read
Ritesh Kadmawala
Ritesh Kadmawala
Founder, Vertexcover Labs - AI-native engineering studio
TL;DR:

Linux provides a native Asynchronous I/O (AIO) API that should theoretically allow true background file operations. Yet popular frameworks like Node.js and Python's asyncio avoid it entirely, relying instead on thread pools with blocking I/O. Why? The answer reveals important lessons about API design, cross-platform compatibility, and the gap between theoretical elegance and practical engineering. The future may lie in io_uring, a modern interface that addresses many of AIO's shortcomings.

Building a LinkedIn Scraper (and Turning It Into an MCP Integration)

· 6 min read
Aman Kumar Singh
Aman Kumar Singh
Software Engineer Intern
TL;DR:

We recently built a LinkedIn scraping tool that can extract profiles, company data, and connections without getting flagged.
Sounds simple, right? Well, three weeks and countless "unusual activity detected" warnings later, We learned that scraping LinkedIn is less about parsing HTML and more about outsmarting their anti-bot systems.

Full source code: github.com/vertexcover-io/linkedin-spider

How We Do Evals & Observability for Agentic Systems

· 7 min read
Harsh Verma
Harsh Verma
Software Engineer
TL;DR:

LLM agentic systems fail in subtle ways. At Vertexcover Labs, we use a 5-part evaluation approach—powered by a structured logging foundation:

  1. Custom reporting/observability app to inspect the step-by-step agent flow (screenshots, LLM traces, code samples, step context, JSON/text blocks, costs).
  2. Component/agent-level tests (like unit tests) to isolate/fix one step without re-running the whole agent.
  3. End-to-end evals that validate the final product output while also comparing each stage to explain failures.
  4. Eval reporting dashboard (Airtable or similar) showing run status with linked "run → steps" tables for fast triage.
  5. Easy promotion of failing production runs into test cases (just use the run_id).

Foundation: a structured logging layer that makes all of the above trivial to build and maintain.

Speed up Docker Builds on Github actions

· 6 min read
TL;DR:
  1. Turn on BuildKit & Buildx everywhere
  2. Reorder Dockerfile: copy package files first, then rest of code
  3. Use cache-mounts with buildkit-cache-dance action
  4. Pick the right cache backend (inline for speed, registry for large images)
  5. Add tmpfs + unsafe-io flags for package installs
ScenarioAvg. wall-clock
No caching1 h 10 m
Layer-cache hit6 m
Layer-cache miss (deps change)52 m
Cache-mount + Cache-Dance8 m

Stop rebuilding the world on every pull-request—turn on these flags and ship faster.

ML Infra design for the GPU Poor

· 5 min read

Taming the Beast: How to Design a Queueing System for GPU-Intensive Workloads​

TL;DR:

When designing for scale, the limiting factor is the GPU availability. So all rate limits / queueing must be designed around GPU availability.

Strot - The API Scraper

· 9 min read
TL;DR:

Strot (Sanskrit meaning source) is an AI agent which scrapes web api:

  1. Instead of scraping the dom, identifies the right api call.
  2. Fast, reliable, complete data scraping for listing data is possible via API scraping.
  3. Strot figures the api call so you don't have to.

Try out Strot!