Rillet Uses AI Agents to Triple Delivery Speed: A Real-World Engineering Practice on Vercel

When a company's core product is an AI-native ERP that helps clients close their books in real time, its own engineering speed has to keep up with client expectations. Rillet's approach is to hand internal workflows over to Agents too: a two-person frontend team closed over 800 Linear tickets in four months, client-requested changes reached production in as little as two hours, and overall delivery velocity tripled in three months.

From "Everyone Building Their Own Wheels" to a Unified Convention: An Agent Is Just a Directory

Rillet frontend lead Anthony Liang has been building AI applications since the GPT-3.5 era and has evaluated virtually every Agent framework on the market—from model vendors' SDKs to the open-source ecosystem. His conclusion: these frameworks only provide the basic primitives of the model loop, but "where instructions go, how tools get registered, how Agents connect to Slack and GitHub" are all decisions you have to make yourself.

That's fine for personal projects, but Rillet wanted even people who have never written TypeScript to be able to get started. So the team chose Vercel's open-source Agent framework eve, which gathers instructions, tools, and skills into a single directory:

agent/
├── agent.ts        # Model and configuration
├── instructions.md # Instructions for the Agent
├── tools/          # Tools the Agent can call
├── skills/         # Knowledge and processes
├── subagents/      # Sub-agents that can be delegated to
├── channels/       # Interaction entry points
└── schedules/      # Scheduled runs

People who understand the business but not code can shape Agent behavior through markdown instructions and skills; tools live in TypeScript files, and the filename becomes the API directly. After moving the Agent from a laptop to Vercel, behavior stays consistent, and all deployments are managed under the company's Vercel organization.

Anthony likens the experience to using Next.js for the first time: "Once you see eve, everything just clicks. It's easy for newcomers to understand how an Agent is put together."

What Is an Agent Framework

An Agent framework is a development library or platform for building AI agents, whose core job is to encapsulate the loop of "model call—tool execution—result return" into reusable primitives. Frameworks on the market broadly fall into two categories: SDKs provided by model vendors (such as the official OpenAI and Anthropic libraries), and general-purpose orchestration frameworks in the open-source ecosystem. Most frameworks only solve loop scheduling and the tool-calling protocol; where system instructions live, how tools are registered, and how Agents connect to external systems like Slack or GitHub are often left for developers to design themselves. This is fine for small personal projects, but when a team needs multi-person collaboration—or even non-engineering roles to participate—the lack of a unified convention leads to every project having a different structure and onboarding costs soaring. A "convention over configuration" framework like eve targets exactly this pain point by converging instructions, tools, and skills into a fixed directory structure, giving Agent projects a predictable organizational form.

Sub-agents and Delegation

A sub-agent is an independent agent invoked on demand by a main Agent to handle a specific subtask. Unlike a "tool," which is typically a stateless function call, a sub-agent has its own instructions, context, and even toolset, and can independently complete a stretch of multi-step reasoning before returning results to the main Agent. Delegation is the scheduling logic by which the main Agent decides when and with what input to invoke a sub-agent. The value of this layered design is complexity isolation: the main Agent only cares about task decomposition and result integration, while domain-specific details are handled by dedicated sub-agents. This avoids overloading a single Agent's context and lets each sub-agent be iterated and replaced independently. In engineering practice, sub-agents are often divided by function—such as spec writing, code generation, and verification testing—forming a pipeline-style collaborative network.

From Ticket to PR: Client Requests Running End to End

In the past, when a client requested a change, information was scattered across Linear tickets, Slack threads, and progress-chasing conversations with engineers. By the time everyone pieced the context together, writing the code was actually the fastest part of the whole thing.

Rillet's customer success team now opens a Chrome extension, highlights the issue the client saw in the Rillet app, and describes the change. After the eve Agent in the extension captures the context, if the change is safe and well-scoped, it hands off to a coding Agent: write the spec, modify the code, open a PR assigned to Anthony. The Agent also launches a browser in a sandbox to verify the change and attaches screenshots as proof; Anthony only needs to review and merge. If changes are needed, the Agent resumes the session to continue.

Rillet's CPA team, through its in-house Agent Nebula, can deliver within two hours of a client request. The company CEO noted that delivery volume in recent weeks exceeded the entire first half of 2026, and that delivery velocity had already tripled in the previous three months. One client remarked that Rillet "completely ruined my expectations for how fast software vendors respond."

A Model Is Just a String: Unified Access with AI Gateway

As more and more Rillet employees started building Agents, connecting directly to Anthropic and OpenAI meant configuring access for each model vendor separately. AI Gateway routes model requests to multiple vendors through a single integration, so builders no longer need to set up provider connections individually.

In eve, switching models only requires changing a string in the configuration:

// agent.ts
import { defineAgent } from "eve";

export default defineAgent({
  model: "zai/glm-5.3",
});

Agents deployed on Vercel automatically authenticate to AI Gateway. Builders can change the model string to try different models for a task without touching the integration. Usage details tell Anthony's team which models were used and how much was spent, making it easy for him to track spend and make model choices as more people build autonomous Agents.

Anthony says: "Being able to access all models with the same key is really critical. Usage visibility is also useful: seeing what people are doing, what models they're using, setting limits—especially as we build autonomous Agents."

AI Gateway and Model Routing

AI Gateway is a unified access layer between applications and multiple model providers. Without it, if a team wants to use models from Anthropic, OpenAI, or other vendors simultaneously, they must apply for keys from each, configure network access, and maintain each SDK version and error-handling logic—any API change from any vendor ripples through the code. AI Gateway converges these differences into one layer: applications face only the gateway's single interface and unified credentials, while the gateway handles authentication, request forwarding, retries, and response normalization. It also brings two operational benefits—observability of usage and cost, and centralized quota and limit management. For teams rapidly experimenting with multiple models, the gateway downgrades "switching models" from an integration overhaul to a configuration change, significantly reducing trial-and-error costs and giving spend attribution and model selection a solid basis.

Enterprise Managed Users and Directory Sync

Enterprise Managed Users is an account governance model in which members don't log in to a platform with personal accounts, but rather with accounts issued and managed centrally by the enterprise identity provider. Directory Sync, meanwhile, synchronizes user and group assignments from the identity provider (such as Google Workspace or Okta) to the platform, automating permission granting and revocation. Combined, the two mean that employee onboarding, transfers, and offboarding automatically reflect in platform access permissions, with no need to manually provision or revoke access one by one. For teams building internal Agents, this means sensitive tools are private by default, access is auditable, and permission sources are single and trusted—satisfying compliance requirements while avoiding the security blind spots that come from scattered personal account management.

Identity and Permissions: Bringing Builders into the Corporate Account System

With more and more Agent builders, Rillet also needed to manage their access to Vercel. Through Enterprise Managed Users, builders log in via Google Workspace single sign-on with company-managed accounts rather than personal accounts. Directory Sync adds and removes permissions based on assignments in the identity provider, so account management follows the company directory.

Ed Hirst, Rillet's founding IT lead, said: "With Vercel, we can ship fast while keeping accounts company-managed, access automated, and internal tools private by default. Being able to control and audit this environment lets me sleep better at night."

Rillet configured Enterprise Managed Users on its own, migrating builders from personal accounts to company-managed accounts in one go, bringing Vercel login and account access into the company's identity provider system.

Next Step: Turning Agents into a Factory

Anthony is building what Rillet internally calls an "Agent factory," so that larger features can go through the same pipeline as small fixes. One Agent writes PRDs and technical specs; another connects to Rillet's Linear board, Miro diagrams, and knowledge base to provide other Agents with the context they need. Using eve's built-in sub-agents and delegation capabilities, these specialized Agents can be added as directories into the same framework.

For a company whose mission is to compress "monthly processes" into "zero days," building Agents with eve and running them on Vercel applies that same pursuit of speed to internal tools. Anthony's summary: "Vercel is great as an all-in-one platform—you can test things, try new ideas, experiment. Deploying an Agent takes under a minute, and seeing changes that fast means a lot."

Rillet's case shows that Agent adoption isn't just about picking a model or framework—it's about designing the directory structure, permission system, model access, and delivery process as a set of engineering conventions. When "the people closest to the customer" can directly drive Agents to complete fixes, faster delivery no longer depends on team size.

One-line Summary

Rillet uses the eve framework and Vercel to engineer internal Agents, tripling a two-person frontend team's delivery velocity in three months.

Paragraph Summary

Rillet's core product is an AI-native ERP that helps clients close their books in real time. To match client expectations, it hands internal workflows to Agents too. After evaluating nearly every Agent framework on the market, frontend lead Anthony Liang chose Vercel's open-source framework eve because it gathers instructions, tools, and skills into a unified directory, letting business people who don't know TypeScript participate in building. The customer success team uses a Chrome extension to highlight issues and trigger a coding Agent, which automatically writes specs, modifies code, opens PRs, and verifies in a sandbox, reaching production in as little as two hours. AI Gateway lets you switch models by changing a single string and provides usage and cost visibility; Enterprise Managed Users and Directory Sync bring builders into the company identity system. The two-person frontend team closed over 800 tickets in four months and tripled delivery velocity in three months. Next up is an "Agent factory" covering larger features.