Agent V: Connecting People and Agents for Autonomous Inference

Inferact Agent V Team

Nov 2026

Engineering

X min read

New models and hardware keep expanding the challenges of inference engineering. Coding agents help us move faster, but they expose another bottleneck: coordination.

Today’s agentic workflows are fragmented, with context scattered across local coding agents, cloud agents, and vertical-specific assistants. At Inferact, we see this daily: engineers copy findings from agents into Slack, and teammates then paste them into other agents. Engineers increasingly act as messengers between agents.

We built Agent V to connect that work. Today, V is a shared internal agent with compounding company knowledge. By simply engaging with V on Slack, our engineers can code together, discuss designs, triage production incidents, or run GPU experiments, even from a mobile device. In the near future, we want V to connect everyone, their agents, their work, and our infrastructure, so that V can drive our engineering efforts end-to-end, with evolving context and human oversight.

Here’s a look at how our team uses V in practice.

SHOWCASE

Teaching V Something New

V maintains a shared memory for the company, which started out empty. Over time, people taught V what it should know.

1A teammate asks V to refuse stamp requests for changes to production deployments.
2After settling the details in the thread, V records the rule in its memory as a standing directive, effective immediately.
3Later, in a different session, another teammate asks for a rush stamp on a production change. V remembers what it was told, and defers approval to a human.

Responding to Production Incidents

We configured V to be the first responder to production incidents, like an autonomous SRE.

1An SLA-violating alert fires; an automatic trigger tags V to start triaging.
2While V works, progress is streamed to the UI (a Slack mod).
3Minutes later, the root cause is identified.

Coordinating with People

V automatically pings other people when needed, giving them the right context.

1A teammate reports loss of access to shared model files in a dev cluster. V found out that all these directories got chown'ed to a single user.
2V automatically starts a side thread to ask this directory owner, providing evidence and proposing a fix.
3This user then applies the fix, responds to V, and V relays the good news to the original thread. Notice how this teammate used a local agent to fix the permissions; in V 2.0, communication to and from a local agent would also be supported by V, without needing a human relay.

Debugging with Agent Swarm

We spawned 16 subagents via V to chase down a really subtle bug. Our agent hillclimb infra provides a shared forum for these subagents and a bidding-based GPU allocation mechanism. We don't prescribe what each agent should look into. They figure out what they can each do towards a common goal.

1Starting the debugging swarm with context.
2V spawns subagents, providing them a charter, a shared workspace, and credentials to the hillclimb infra.
3Hours later, the subagents figured out the root cause.

Inference Optimization

Given the goal of beating the published DeepSeek-V4.1-Flash results on H200, six agents explored in parallel and built on each other's findings.

1A teammate kicks off the hillclimb from previous context.
2During the hillclimb, another teammate asks for the current progress.
3Later, a separate private V conversation steers the hillclimb in a new direction. This is a cross-session message, a key feature of Agent V that empowers people and agents to directly collaborate across the company.
4One of the final performance charts V generates.

Ordering DoorDash

This was not a built-in feature of Agent V; a teammate taught V to run weekday dinner orders, through V, including setting up the necessary credentials.

1V announces the delivery.
2A teammate thinks their order failed. V checks and confirms it went through.

Organic Growth: A Positive Feedback Loop, Powered by a Mix of Models

Daily and weekly active users of Agent V since launchOrganic weekly active users climbed from 3 at launch in mid-September to roughly 60 by early November, with daily active users peaking at 43.WEEKLY ACTIVE (TRAILING 7 DAYS)DAILY ACTIVE0204060UNIQUE PEOPLESep 21Sep 28Oct 5Oct 12Oct 19Oct 26Nov 2PEAK DAU · 43WAU ≈ 60
Daily and weekly active users since launch, counting organic usage only: distinct people who started or joined a session by talking to V, each day and over the trailing seven days. Automated pull-request approvals and specialist-agent sessions, which would inflate these numbers, are left out. Data through Nov 8, 2026.

Since V’s internal launch in September, it has handled 7,400+ sessions, with 80% of the company as weekly active users. We have never mandated nor incentivized the usage of V; instead, this organic growth comes from a positive feedback loop: people push V’s capabilities, inspiring more features and UX improvements; we then implement them, enabling more users to use V for their daily tasks.

Our self-hosted Kimi K3 is the default model for sessions started by people, and users keep it in about 88% of those sessions. Across all workloads, Kimi K3 and K3.1 have processed 55% of V’s tokens, with a KV cache hit rate above 96%.

Share of all tokens processed by Agent V, by modelKimi K3 and K3.1 account for 54.6% of all tokens processed, Claude Opus 5.5 for 30.6%, GPT Sol 6 and 6.1 for 13.6%, and other models for 1.2%.SHARE OF ALL TOKENS PROCESSEDOTHER · 1.2%54.6%KIMI K3 / K3.130.6%CLAUDE OPUS 5.513.6%GPT SOL 6 / 6.1
Share of all tokens processed by Agent V, by model, including subagents and pinned code-review sessions.

As we use a mix of open and closed models to solve real inference problems, we find that in many cases, properly harnessed open-weight models can solve problems as well as closed ones, especially when the goals are well-defined, such as complex debugging or performance optimizations. Furthermore, having a panel of different models leads to more comprehensive code and design reviews. This reinforces our approach with Agent V, as a unified platform that allows all models to work together to achieve more than what any single model can.

Pull requests to Agent V's own code per weekWeekly pull requests to Agent V's codebase from September 7 through November 2, stacked by Written with V, Written with V for V 2.0 (surging to 158 PRs in the week of Nov 2), and Written without V.WRITTEN WITH VWRITTEN WITH V, FOR V 2.0WRITTEN WITHOUT V05010015011Sep 71162Sep 141875Sep 216313Sep 281919Oct 527Oct 123845Oct 1913Oct 26158Nov 2
Pull requests to Agent V's own code per week, by author: V (directed by an engineer) or a person working without V. “V 2.0” is the rewrite started in late October. Data through Nov 8, 2026.

The growing demand of V has already outgrown its current architectural limitations, so we’re working on the next iteration, V 2.0, and we now primarily use V to develop itself. We’ll discuss at the end of this blog post what exciting features we’re building for 2.0.

How V Works

Connecting people, agents, and infrastructure raises hard engineering questions: How do we share context and organize memory? How do we give agents access to sensitive services while protecting credentials and controlling production changes? And how do we keep the system reliable when any component can fail?

These problems are hard to solve, so we started with a minimal prototype, and immediately went live. Through our daily use, we learned what features to add and where the designs came short. As we keep iterating, we now have a core architecture that not only supports today’s use cases, but serves as a foundation for our vision of autonomous inference and self-improvement.

The Architecture

V runs a cluster of agent sandboxes that connect to other systems via the central Gateway. The gateway routes people’s messages, handles agent-initiated external tool calls, brokers access to services, and manages persistent memory.

Slack is V’s primary interface today. When someone tags V in a new thread, the gateway starts a sandbox in V’s Kubernetes cluster. Each sandbox runs Pi, the agent harness, with tools provided through the gateway. Idle sandboxes are shut down, while most workspace state is retained on persistent storage through a Kubernetes persistent volume claim (PVC).

The gateway provides tools for Slack, scheduling, and access to third-party services. Most calls are asynchronous, so agents can continue working while waiting for results. Timers are managed by the gateway because the sandbox that created them may no longer be running when they fire, and Slack communication is managed by the gateway for security and reliable delivery. We also provide cloud VM and GPU fleet access tools, to facilitate workloads requiring GPUs or a bare OS. The agents can also serve live or persistent artifacts via the gateway, useful for visualizations and technical explainers.

Sessions record reusable findings in Inferact Memory, a shared Git repository. For V 2.0, we plan to support separate private and public-facing memories. The next section explains how this memory is organized.

Connecting internal infrastructure and external services makes access control a central design concern. The security section explains how the gateway protects credentials and limits what each agent can do.

Agent V architectureAgent V Gateway connects Agent UI (Slack, Web Mirror, and V 2.0 Local and Remote Agents), Agent V Kubernetes Sandboxes running Pi with persistent PVCs, Memory (Inferact Memory plus V 2.0 multi-tenant Private and Public Memory stacks), Helper Services (Static Artifacts / Live Preview, Hillclimbing, VMs), and External Services (HTTP Proxy, SSH Broker, OAuth Broker, Cloudflare Tunnel and more connected to a Cloud KMS Credentials Vault).AGENT V ARCHITECTUREIn V todayPartial today · improved in 2.0V 2.0AGENT UISlackthreads, channels, DMsWeb Mirrorlive session viewSUPPORTED IN V 2.0Local AgentsClaude Code, Codex…Remote Agentscloud & remote controlAGENT V K8SKubernetes sandbox clusterSandboxes1 ISOLATED POD PER SESSIONPiAgent harnessasync tools · subagentsPersistent PVCWorkspace volumestate survives idleAGENT V GATEWAYMEMORYInferact Memorycompany-wide Git repositoryV 2.0 · MULTI-TENANCYPrivateMemoryDMs, privateprojectsPublicMemoryvLLM OSSsupportHELPER SERVICESStatic Artifacts /Live PreviewHillclimbingforum, GPU market, lineageVMsdisposable Docker & sudoEXTERNAL SERVICESPARTIALLY SUPPORTED · IMPROVED IN V 2.0HTTP ProxySSH BrokerOAuth BrokerCloudflare TunnelCredentials Vault (Cloud KMS)Messagesagents ↔ humans · agents ↔ agentsSandbox lifecycleteardown & recreateExternal tool calls ↔ resultsTranscripts stream ↓Shared memoryorg & tenant contextHelper servicestools that make V usefulSecure accessto external services

Understanding the Company via Inferact Memory

A finding from one investigation should help the next person who encounters the problem. Inferact Memory gives V sessions a shared place to record instructions, facts, procedures, and lessons. Teams have used it to rediscover internal tools and recognize work that has already been done. The underlying store is a Git repository, organized into four kinds of entries:

69Directives
131Facts
42Skills
1,056Learnings
  • Directives: Instructions that humans specifically told V to follow, to steer V’s behavior.
  • Facts: Information discovered, or presented by humans, that could not have been found without serious effort, (e.g. where the clusters are; where the GitHub repos are), organized by category.
  • Skills: “SKILLS.md” in the traditional agentic sense, one for each specific procedure, with an index so V knows when to use each skill; for example, V has a v-self-improvement skill.
  • Learnings: A catch-all append-only log of freeform memory that each session can choose to write down, which later sessions can search through.

Inferact Memory started out completely empty (except for this structure), and everything was taught by conversing with V.

The session ends. The lesson remains.A human instruction taught in Session A is committed to Inferact Memory under Directives, persists after Session A's ephemeral pod is torn down, and guides a later session to ask a human for approval.SESSION A · EPHEMERAL“Refuse rush stamps onprod changes.”pod-aPOD TORN DOWNSession ends when idleephemeral sandbox torn downINFERACT MEMORY · GIT REPOmemory.gitDIRECTIVES69FACTS131SKILLS42LEARNINGS1,056Standing directive committedversioned & searchable org-wideA LATER SESSIONpod-bloads directive at startupAsk a human to approvedefers prod stamp in Slackgit commitread memory

An org-wide memory proves to be surprisingly powerful, even more than we expected. People are regularly amazed by how much V knows. Internal tools that were once forgotten are discovered again and automatically used for appropriate tasks. Previous learnings help people recognize when they are about to duplicate work.

We are continuing to experiment with new ways to improve org-wide memory. We built Inferact Overflow, an internal Q&A board where humans and agents answer each other’s questions. We’re also experimenting with real-time memory so V is aware of recent events such as ongoing production incidents.

Accessing Services Securely

Our engineers work across many Slurm clusters for development, Kubernetes clusters for production, several clouds, and services such as GitHub, Docker Hub, Hugging Face and Datadog. We want Agent V to help with work across these systems, so it needs access to them.

The straightforward approach would be to hand V every credential it needs. That would make the services accessible, but a single prompt injection could expose the organization’s long-lived API keys, potentially without us knowing.

We take security as seriously as capability. A V sandbox should have only the privileges it needs for its current task, without holding long-lived credentials. Protecting the keys is only part of the problem: we must also control how agents use their access. The ability to change a production deployment does not by itself authorize V to make that change.

For a local personal agent, access is relatively easy: the user authorizes it with OAuth, or point it at a token or SSH key. For a company agent that can be prompted on Slack, the same approach has many drawbacks: requiring an interactive login during a Slack chat would bring a lot of UX friction, and the security problem would remain, because this shared company agent could then act as the people who have the broadest permissions.

There is no simple answer, and a lot of V’s engineering time is invested here. The V Gateway brokers access through at least five kinds of authentication, each scoped to what a task needs: repository-scoped GitHub credentials, per-task credentials for third-party services, short-lived SSH certificates for our GPU clusters, a read-only proxy for Kubernetes, and ad-hoc secrets that a person supplies for a single task.

The most sensitive access is additionally secured via isolation. These credentials cannot be accessed by normal sessions at all; the only way to use them is through specialist agents. A specialist agent runs in a sandbox with fixed instructions, no memory, and a fixed policy acting as an LLM judge. A GCP specialist, for example, can hold broad permissions while its policy forbids deleting production deployments and requires a human to approve other risky changes.

Accessing services securely via isolated specialist agentsA normal V session holds no standing credentials and sends a scoped request via the Gateway to an isolated Specialist Agent with fixed instructions, fixed policy, no memory, and isolated elevated credentials, which judges whether to execute, ask a human via an approval card in Slack, or deny with a reason.sessionV sessionno standing credentialsGATEWAYscoped brokerISOLATED SANDBOXSpecialist agentfixed instructionsimmutable charterfixed policyLLM judgeno memoryunpoisonableelevated credentialisolated vault grantexecuteGCP · Kubernetes · Slurmask a humanapproval card in Slackdenywith a reasonrequestExample policy: broad GCP rights; never delete production clusters; risky changes need human approval.

Our work with Agent V’s security is far from done, and we look forward to diving deeper in a second blog post.

Coordinating Across Conversations

Slack is already where our team communicates, so it was the first interface we supported for V. Building a useful Slack agent is harder than it sounds: conversations are fragmented, ambiguous, and highly contextual.

Feeding every conversation to a single agent would give it plenty of context, but it would quickly become confused. Giving each thread its own agent keeps conversations separate, but that agent can miss important context people discussed in another thread just a minute earlier. Even within one thread, a person may ask V a serious question in one message and joke about V in the next. V needs both a way to carry context between conversations and a way to decide when it should respond.

When a teammate lost access to shared model files, V identified an ownership change, opened a side thread with the directory owner, and relayed the result after the owner fixed the permissions. The engineer made the change; V carried the evidence and follow-up between conversations. Cross-thread messaging makes this kind of coordination possible within the place our team already works.

Several capabilities support this coordination:

  • Cross-thread messaging. A V session can open side threads on Slack, start or fork a new session, send a message to a separate session, or watch another thread. This allows multiple workstreams to be aware of each other.
  • Controlling V’s attention. A decider is used to determine whether a message is intended for V, so V doesn’t respond extraneously when it’s not needed. This was a pain point with another major Slack-based agent we used before. Also, because long-running tools we give to Pi are async, new messages can be delivered to the agent at any time, making the conversation feel alive and real-time.
  • Slack feature coverage. We provide tools to Agent V that cover the entire Slack surface, including channel and thread reads, reactions, attachments (upload and download), search, as well as interactive elements like approval cards and question cards. This ensures that V can see what humans see.
  • A Slack Mod. The Slack UI was not designed to display an agentic session. We made a Slack mod that makes V sessions easy to find, streams V’s work in real time, and provides many QoL improvements. The screenshots presented in this blog post are taken right in Slack with this mod installed. For people using V without the mod, we provide the Web Mirror, a similar interface on the web.

Subagents and Hillclimbing

Parallel subagents are becoming increasingly popular, as they are highly useful in tackling complex problems. V supports subagents natively, with the added benefit that each subagent can use a different model. With multiple open and closed models becoming so capable, combining their intelligence yields even better results. For example, when iteratively designing the most complex pieces of V 2.0, we find that combining Gemini 4 Carbon subagents with Claude Opus 5.5 subagents yields better results than either alone. In V 2.0, local agents can also leverage the power of V's subagents, so people will not need to migrate their existing workflows.

One common task that we do with parallel agents is to have them collectively optimize a verifiable metric, which is often called hillclimbing. At Inferact, we tackle inference problems, whose verification almost always requires GPUs, a scarce resource. We therefore built a hillclimb exchange:

  • GPU Bidding. Subagents are given GPU credits each hour, and they must bid on GPU resources to use them. The price per GPU minute is controlled based on demand and available capacity. This incentivizes subagents to make microbenchmarks rather than blind trial-and-error.
  • Rewards and Lineage. A subagent may submit a candidate for verification, which also requires GPU credits. If it results in a new record, the subagent is rewarded with more credits. Furthermore, to encourage collaboration, submissions are organized in a git tree, and other submissions along the lineage of the record submission are also rewarded.‍
  • Agent Forum. A forum is made available for agents to discuss findings, similar to Inferact Overflow, but instanced to this hillclimbing run. This allows agents to share findings, and also to autonomously coordinate work, since we do not assign subagents any specific tasks at the beginning.
Progress follows a lineage on the hillclimb exchangeParallel subagents running mixed models explore hypotheses toward a common verifiable goal, share findings on the Agent Forum, bid hourly GPU credits on scarce GPU nodes, and earn lineage rewards across the Git tree when a candidate sets a new verified record.HILLCLIMB EXCHANGE · PARALLEL MIXED-MODEL SUBAGENTS · ONE GOALBASELINEcommon goalAGENT 1Opus 5.5AGENT 2Kimi K3AGENT 3Gemini 4AGENT 4Kimi K3AGENT 5Gemini 4AGENT 6Opus 5.5VERIFIED RECORDGPU bidGPU VERIFICATIONscarce H200 / GPU nodesAGENT FORUMPosts, replies & findings scoped to runAgents decide autonomously who exploreswhat; one finding sparks another’s branch.finding #14 → unblocks Agent 5GPU BIDDING MARKETHourly GPU credits · dynamic $/GPU-minIncentivizes cheap microbenchmarks firstn1n2n3n4scarce GPU nodesREWARDS + GIT LINEAGEEach submission names its Git parentA new record rewards its entire lineagecredits paid along winning path

We find that the hillclimb exchange is also very useful for non-optimization tasks, including complex debugging where agents must investigate many theories, writing complex technical explainers where agents review each other’s work, and tackling complex system designs.

Building V 2.0

V 1.0 was built to learn quickly: make a working version, let user feedback drive features, and fix bugs as they appear. One of our engineers, working extensively with coding agents, built most of V in about a month.

Continuing to add features and patch bugs seemed like the natural way to meet growing demand. But building this way was like making a tower from a messy pile of bricks: eventually, it stopped getting taller. The design became harder to understand. Even with Opus 5.5, one recent bug took four attempts to fix, each adding more than 1,000 lines of code. More patches could not give us the foundation we needed. As agents write more of the code, humans must still understand the system well enough to guide its development and verify its behavior.

That is why we are rebuilding V 2.0 around a modular architecture, explicit boundaries, and clearly defined behavior under failure. This takes longer at the start: the same engineer spent seven full days on the core architecture, reviewing the design 35 times. We’re expanding to a small team while keeping every critical component understood. The goal is a foundation that people and agents can extend safely, including improvements to V itself.

We’re building toward four capabilities:

  • Private workspaces and memory. Separate memory, tools, and service access for private conversations, internal teams, and external communities. This will let us bring V into more settings, including the open-source vLLM Slack.
  • Connected agents. Local, cloud, and Slack-based agents will be able to exchange messages, delegate work, and share knowledge within permission boundaries. Engineers can keep their preferred tools while collaborating through V.‍
  • Secure service access. Reviewed access mechanisms will let agents use services without exposing durable credentials to their sandboxes. Individuals will be able to authorize V to act on their behalf through securely stored credentials.‍
  • Reliable execution at scale. We’re designing for thousands of concurrent agents, durable messaging, recovery from failures, and safeguards against duplicate tool execution.

Toward Open Autonomous Inference

Autonomous inference and self-improvement loopAutonomous inference and self-improvement loop with Agent V: four iterative agent loops (Iterative Design and Implementation, Iterative Experimentation and Optimization, Production Deployment and Upstream vLLM, and Iterative Evolution of Agent V) cycle continuously in a clockwise flywheel while Humans in the center step in via spokes for guidance and decision making, setting priorities and coordinating compute, privileged actions and rollout sign-off, and teaching memory, approval and oversight.AUTONOMOUS INFERENCE & SELF-IMPROVEMENT LOOPAgent-driven loopsHumans step in where neededGuidance,decision makingSetting priorities,coordinating computePrivileged actions,rollout sign-offTeaching memory,approval & oversight01 · DESIGN & CODEIterative Design &Implementationspecs, multi-modelreviews & PRs02 · EXPERIMENTATIONIterative Experimentation& Optimizationhillclimbing kernels &end-to-end serving03 · PRODUCTION & OSSProduction Deployment& Upstream vLLMshadow/canary rollouts,incident triage & vLLM PRs04 · SELF-IMPROVEMENTIterative Evolutionof Agent Vupdating memory, skills& V’s own codebaseHumans

Agent V is how we’re putting our vision for autonomous inference into practice: connecting investigation, implementation, experimentation, and production into a continuous development loop.

People set priorities, guide ambiguous decisions, allocate scarce compute, and approve sensitive changes. Agents carry work between those decisions, preserving findings so each experiment can build on what came before.

As that loop improves, we aim to bring new models into production faster, improve their performance, and contribute validated improvements upstream to vLLM. V brings people and agents together to make that work compound.

Acknowledgments

  • Robin Cheng leads the engineering effort for Agent V.
  • Simon Mo invented the idea and, together with Woosuk Kwon, guides the direction for autonomous inference.
  • Roger Wang was one of V’s earliest users and has been a constant source of ideas, encouragement and advocacy.
  • Steven Lin built much of V’s multimodal integration.
  • Kevin Luu, Dao Le, and Steve Gilmore helped shape V’s security design, especially in the early days.
  • Our hillclimbing infrastructure was inspired by Brayden Borges and the SquidProxyLover CTF team, whose hillclimbing setup Robin saw firsthand when playing with them at the DEF CON CTF Finals. Brayden generously walked us through how he runs hillclimbs and what he has learned along the way.

Most importantly, Agent V is a fruit of the whole Inferact team. People welcomed V from the moment it went live. They pushed its boundaries since day one, asking V to do real work, without fearing it would slow them down. When it didn’t work, they taught V what to do, and sent feedback, motivating Robin to keep improving V. Everything in V’s memory was taught by a colleague who took the time, and every thread in the above showcase is someone's real work, done in a channel so others can benefit from it.

V exists because we have curious people who embrace new ideas and empower each other. If that sounds like a great place to work to you, we have open doors.

Running at volume?

Tell us a model to serve. We’ll help optimize it.

Talk to an engineer