Frappeverse DevTools keynote: AI writes the first draft, craft finishes the job

Frappe’s DevTools keynote at Frappeverse Mumbai 2026 made a clear argument: generating more code is no longer the difficult part. The harder work is deciding what should be built, keeping it coherent, and giving people enough control to finish it properly.

Faris Ansari, Frappe’s principal product engineer, captured that idea in one line: “Code is cheap, but craft is not.” The rest of the keynote showed a connected set of tools moving in that direction. Frappe UI and Espresso provide shared interface foundations. Studio and Builder pair generation with visual control. frappectl gives agents a simple way to operate Frappe sites. Flow takes that idea into business workflows, while Grove is a planned LLM inferencing platform for hosting more of the underlying model stack.

The release states are mixed. Current interface and Builder improvements sit beside experiments such as frappectl, pre-stable Studio work, an unreleased fuller version of Flow and the newly teased Grove platform. Together, they show the development direction Frappe is building around agents.

Frappe UI is turning taste into infrastructure

Faris began with the small interface decisions that users notice even when they cannot name them: a dropdown that remains keyboard-accessible, flips when it reaches the edge of a screen, and places a submenu where there is actually room; a numeric column whose sort icon does not break alignment; a list divider that begins at the text instead of cutting through an avatar.

These details are now being pulled into Espresso 2.0, Frappe’s design system. The team mapped existing Frappe applications, found recurring patterns, removed inconsistent treatments, and documented how components should and should not be used. Faris described Espresso 2.0 as battle-tested in real apps rather than designed in isolation.

The work is leading into Frappe UI v1. Faris showed a library with 115 components, more than 1,000 unit tests compared with roughly 30 before, and almost complete TypeScript coverage. He said about 30 Frappe applications and around 100 community applications now use Frappe UI.

Agents helped the team get there, but they did not make the product decisions. Faris used them to study how applications were working around gaps in Frappe UI, review code, and apply a shared philosophy.md to new components and pull requests. The model handles more of the repetition, while the component library preserves the decisions that make the result feel intentional.

Studio keeps the generated interface editable

Rucha Mahabal, an engineering lead at Frappe, presented Studio as a visual app builder combining Frappe UI, Frappe Framework and the composition tools associated with Builder. Her answer to “why use a visual builder when an agent can write the interface?” was practical: generated markup still needs to be inspected, rearranged and corrected.

In the demo, an agent generated a front end for ERPNext’s Projects module in under a minute. Studio then made the output directly editable. Rucha removed unnecessary copy, reordered sections, changed spacing, moved a badge, and corrected status colours without returning to a long prompting loop.

The underlying architecture has also changed. Studio front ends can be exported with a Frappe app. App-specific builds include only the components a project uses, while developers can add custom Vue components, stores and composables instead of waiting for Studio to expose every possibility through a configuration panel.

Frappe is already using Studio internally. The customer portal shown in the previous day’s Helpdesk keynote was built with it, and the team is also using it for a partner-and-customer Connect app. But Studio is not at a stable release yet. Rucha said the team is dogfooding it, plans to battle-test Studio applications in production, and will build the end-user customization layer before a stable release.

Studio already demonstrates a useful workflow, but its most ambitious promise, high-fidelity visual customization of crafted Frappe apps, remains ahead.

Builder combines a fast draft with precise editing

Suraj Shetty, a product engineer focused on Frappe Builder, arrived at a similar conclusion from website creation. An AI model can produce the first draft quickly; the last stretch still needs a capable editor.

Builder’s assistant understands its component system, scripting model and data connections. In the keynote demo, it generated a sneaker landing page, added a scripted carousel, created a DocType, and wired a quotation form to it. The user could then take over in Builder instead of repeatedly describing visual changes in a prompt. The assistant was demonstrated onstage; Frappe did not announce general availability.

Several more conventional improvements make that handoff useful. Blocks can now be rearranged directly on the canvas. Images can be cropped and repositioned inside Builder. Component-level properties and scripts make self-contained widgets possible without filling a page with script. Version history can restore an earlier design or copy an element from one version into the current page.

Builder now includes more than 30 page templates and click-through-rate tracking for links. Frappe has also moved Builder to the MIT licence, making it easier for developers to adopt and extend. A plugin system is under development, with working experiments for features such as animations and theme generation, but Suraj presented those as experiments rather than finished releases.

The model can create quickly, while the visual tool remains available for the decisions that follow.

frappectl gives agents a simple door into Frappe

Ankush Menat, Frappe’s chief technology officer, was explicit that the next part of the keynote covered experiments. His starting point was frappectl, a command-line interface that maps commands to Frappe’s REST API.

An authenticated user can list or retrieve documents from a site using ordinary command-line tools. An agent can build on the same interface, discover DocTypes, inspect schemas, compose commands, and operate the site through a small set of general tools. Frappe does not need to build a custom assistant for every application.

Ankush organized the approach around discovery, tools and skills. The agent first discovers how an application stores its data. General tools let it read and act. Skills provide application-specific context when reverse engineering the same workflow each time would be wasteful.

Frappe applications remain usable by people, while agent harnesses get a consistent way to work with them. It avoids turning every screen into a chat box and gives Frappe one integration surface to improve.

Flow brings the agent runtime into business work

Shrihari Mahabal, an engineer at Frappe, introduced Flow as a new and upcoming product. The assistant knows about business data, respects Frappe permissions and can operate on a user’s behalf.

The demos went beyond a generic chat interface. Flow generated a sales analysis and could turn the request into a recurring monthly routine. A customer-support example built an agent from past resolved Helpdesk tickets and articles. Flow converted that material into vectors, retrieved the relevant chunks for a new question, and used them as context for a response.

Underneath the assistant is a portable agent runtime, also called Flow. It has five general tools: read, write, edit, Bash and grep. It also accepts tools exposed by a client application over an API. Flow does not require Frappe to be installed and can connect to other clients. Shrihari also showed it modifying itself and creating a browser extension when it needed web access.

This is still work in progress. Shrihari said the version demonstrated onstage has not been released. A much smaller version exists on Frappe’s GitHub, while the team plans to stress-test the fuller system through internal automation before launching it.

Grove would give Frappe more control over inference

Ankush closed the DevTools keynote with Grove, a planned LLM inferencing platform he summarized as “Frappe Press, but for LLMs.” The onstage system was already running a self-hosted DeepSeek model. The proposal is to give Frappe more control over data and costs while serving the growing demand for open-weight models.

This was a direction, not a release announcement. The closing slide connected Framework, Flow and Grove, while the wider keynote showed visual tools for shaping what agents generate.

Frappe is making its foundations more consistent, giving agents more of the mechanical work and preserving a place for people to inspect and improve the result. Studio still needs the production battle-testing and customization layer described onstage. The fuller Flow needs internal stress testing before release. Grove is earlier still: a named direction for an inference layer, with public availability yet to be announced.

Watch the full Day 2 Track 1 livestream from the start of this keynote