Uncovering the technical secrets behind Cursor, Perplexity, and Lovable: Why they all chose the “anti-framework” route

Have you ever wondered why Cursor, v0, Perplexity, Lovable, Bold, and other top AI agent products with millions of users all have one surprising thing in common? None of them are built on any AI framework.While the entire industry is frantically chasing the latest AI frameworks, attempting to simplify development through layers of abstraction, these truly successful products have taken the opposite approach—they are built directly on AI primitives, using the simplest methods to solve the most complex problems. This is no coincidence; it reveals a fundamental truth we may have overlooked: in the rapidly evolving AI era, the abstraction provided by frameworks may actually be the biggest obstacle to innovation and scalability.

Recently, I conducted an in-depth study of a speech by Ahmad Awais, founder and CEO of Langbase. Ahmad is no ordinary individual; his technical background is legendary: contributor to NASA helicopter mission code, member of Google's Developer Advisory Board, former Vice President of Developer Tools, and core contributor to renowned open-source projects such as WordPress, Next.js, Node.js, and React.His open-source packages are downloaded an astonishing 40-50 million times per year, and he created the popular Shades of Purple code theme.

More importantly, he has been deeply involved in LLM technology development since 2020, when GPT-3 was only a month old and Greg Brockman gave him direct access, a year before GitHub Copilot began building code generation tools.This technical depth gives his insights into AI agent construction particular weight. In this talk, he not only built eight different AI agent architectures using basic building blocks, but also proposed a disruptive idea: the best AI agents should be assembled using basic building blocks, like building blocks, rather than being constrained by the abstraction layers of a framework.

The pitfalls of frameworks: Why abstraction has become a productivity killer

Over his decade-plus technical career, Ahmad has witnessed countless technological cycles, but the situation in the AI field has led him to rethink the very purpose of frameworks. Ahmad cuts to the core in his speech: frameworks do not truly add value; they are bloated, slow to iterate, and filled with abstractions that no one actually needs. This viewpoint may sound harsh at first, but upon deeper reflection, it hits the nail on the head regarding the core pain points of current AI development.

In traditional software development, frameworks are valuable because the technology stack is relatively stable and business models are relatively fixed. Abstractions help developers handle repetitive tasks and improve development efficiency. However, the AI field is entirely different. New large models are released every few weeks, new agent architectures emerge, and new capability boundaries are constantly being pushed. As Ahmad put it, the field changes so rapidly that any predefined abstractions may quickly become obsolete.What's worse is that when you heavily rely on a particular framework, you are locked into that specific abstraction layer. When there is a major technological breakthrough, it is difficult to adapt quickly because you either have to wait for the framework author to update it (which usually takes a long time) or go through the painstaking process of migrating to a new framework.

I particularly agree with Ahmad's classic example of Amazon S3.S3 was able to support the entire cloud computing ecosystem not because it provided a complex object storage framework, but because it offered extremely simple basic units: uploading data and downloading data. With just these two basic operations, it supported countless complex application scenarios, from simple file storage to complex data lake architectures. The core of this design philosophy lies in providing sufficiently powerful underlying capabilities that allow developers to flexibly combine them according to specific needs, rather than attempting to predict all possible use cases and provide corresponding abstractions.

From a production practice perspective, I have found that the biggest problem with most current AI frameworks is that they attempt to solve an inherently unsolvable problem: how to provide stable abstractions for a rapidly evolving technical field. This is like trying to create an accurate topographical map of an erupting volcano—doomed to fail. Another issue with frameworks is that they often become overly generalized, introducing numerous configuration options and abstraction layers to accommodate various potential use cases, ultimately becoming both complex and inefficient.In a field like AI, where performance and response speed are extremely important, this kind of bloat is unacceptable.

Ahmad's other profound insight is that most engineers are rapidly transforming into AI engineers. Front-end developers, back-end developers, DevOps engineers, and ML engineers are all learning how to integrate AI capabilities into their products. This transformation requires us to rethink the design philosophy of development tools.These engineers already have extensive programming experience and established thought patterns. What they need is not another complex framework or abstract concepts, but basic building blocks that can be directly manipulated using familiar programming languages and patterns. As demonstrated in the presentation, AI agents built using basic building blocks are essentially ordinary JavaScript/TypeScript code that any developer with programming experience can immediately understand and modify.

The power of AI building blocks: building intelligence like Lego

After studying Ahmad's methodology in depth, I began to rethink the fundamental architecture of AI agents. I discovered that no matter how complex an AI agent is, its core can be broken down into a few basic building blocks, just like the periodic table of chemical elements, where all compounds are composed of basic elements.Ahmad identified several key AI basic units in his presentation: Memory (a long-term memory system with vector storage capabilities), Thread (dialogue context and state management), Tools (ability to call external tools), Parser (multi-format data parsing), Chunker (document segmentation and preprocessing), Router (intelligent routing decisions), and Evaluator (quality assessment and feedback).

The beauty of these basic units lies in their composability and specialization. Each unit focuses on solving a specific problem and excels at it, then combines flexibly to build complex functions. This is the perfect embodiment of the Unix philosophy of “do one thing and do it well” in the AI era.The Memory unit does not need to worry about how to parse PDFs, and the Parser unit does not need to consider how to store vectors. Each unit has clear responsibilities, making the entire system both efficient and easy to understand.

In the live demonstration of his presentation, Ahmad simply said “chat with PDF,” and his CHAI system automatically identified which basic units were needed and generated the complete implementation code.The entire process was impressive: the system automatically determined that a Memory unit was needed to store PDF content (including vector storage functionality), a Parser unit to process PDF format, a Chunker unit to split long documents, and an LLM unit to understand the question and generate answers. Most importantly, the generated code had no framework dependencies—it was pure JavaScript code, clear, readable, and easy to modify.

The demonstration left me deeply impressed. Ahmad uploaded several PDF files, including his personal profile, presentation information, and Langbase API documentation. The Parser unit automatically converted these PDFs into text, the Chunker unit split the long documents into manageable segments, and the Memory unit automatically vectorized and stored the data—all completely automated.When he asked, “Who is the founder and what were the topics of his last three speeches?”, the agent was able to find relevant information across multiple documents and provide accurate answers. This ability to integrate information across documents is a powerful demonstration of the power of basic unit combinations.

I particularly appreciate the transparency and controllability of this architecture. Unlike black box frameworks, a system based on basic units allows you to clearly see what happens at each step, understand how data flows, and easily locate and debug problems when they arise.Ahmad even found a small bug during the demo, which he was able to fix quickly in “vibe code” mode without having to delve into complex framework source code or wait for a framework update. This immediate feedback and direct control are critical in a production environment.

From an architectural evolution perspective, I believe the basic unit approach is more in line with the natural evolution of software systems.Complex systems often evolve from simple components rather than being designed to be complex from the outset. Basic units provide such an evolutionary path: you can start with the simplest combination and gradually add more units according to actual needs, with each step being controllable and verifiable. This incremental approach not only reduces risk but also makes the system easier to maintain and extend.

Eight architectural patterns: production practices for combining basic units

Ahmad demonstrated eight different AI agent architecture patterns in his presentation, each based on different combinations of basic units. These architecture patterns not only showcase the powerful combination capabilities of basic units but more importantly, they cover the vast majority of AI agent requirements in current production environments. After careful analysis, I found that these eight patterns actually form a complete AI agent design language capable of addressing various scenarios from simple question-answering to complex reasoning.

The first is the Augmented LLM (Augmented Large Language Model) architecture, which is the most basic and commonly used pattern. It combines LLM with basic units such as Tools, Thread, and Memory to form an intelligent agent capable of invoking external tools, maintaining dialogue state, and accessing long-term memory. In this architecture, LLM is no longer an isolated text generator but an intelligent agent capable of perceiving the environment, invoking tools, and learning from memory.Ahmad emphasized that the key to this architecture is that each basic unit is independent and replaceable, allowing you to choose the most appropriate implementation according to specific needs.

The second is the prompt chaining and composition architecture, which handles complex multi-step tasks by concatenating multiple specialized agents. Ahmad demonstrated an example of marketing content generation, which included a summary agent, a feature extraction agent, and a marketing copy agent.Each agent has a clear division of responsibilities and works in a predetermined order, using the output of the previous agent as input for the next one. The ingenuity of this design lies in the fact that each agent can use the model best suited to its task, such as using Gemini for summarization (due to its excellent understanding and summarization capabilities), Claude for reasoning (due to its stronger logical analysis capabilities), and GPT-4 for programming (due to its outstanding code generation capabilities).

The third architecture is the Agent Router architecture, which is one of my personal favorites. In this architecture, an intelligent routing agent analyzes user input and decides which specialized execution agent to invoke. Ahmad built a system with three specialized agents: a summarization agent (using Gemini), an inference agent (using DeepSeek Llama 70B), and a programming agent (using Claude Sonnet).When a user asks, “Why are days shorter in winter?” the routing agent correctly identifies this as a question requiring scientific reasoning and automatically routes the task to the reasoning agent for processing. The value of this architecture lies in its ability to automatically select the optimal processing path based on task characteristics, and each specialized agent can be independently optimized and upgraded.

The fourth is the Parallel Agent architecture, which leverages the concurrency capabilities of modern programming languages to run multiple agents simultaneously to handle different aspects of the same input. In JavaScript, this can be easily achieved using Promise.all.For example, for a piece of customer feedback, you can run an emotion analysis agent, a key information extraction agent, and a problem classification agent simultaneously, and then combine the results to form a comprehensive analysis report. This parallel processing not only greatly improves efficiency, but also analyzes problems from multiple angles simultaneously to gain more comprehensive insights.

The fifth is the Orchestrator-Worker architecture, which I think is the most innovative model, as it simulates the way human teams collaborate.An orchestrator agent is responsible for analyzing complex tasks, breaking them down into multiple subtasks, assigning them to multiple worker agents for parallel processing, and finally integrating all results into the final output via a synthesis agent. Ahmad's blog writing example is particularly insightful: the orchestrator breaks down “write a blog about the benefits of remote work” into five specific subtasks: write an introduction, write the productivity section, write the work-life balance section, write the environmental impact section, and write the conclusion.Five worker agents work in parallel, each focusing on their own part, and finally, an integrator agent combines all parts into a coherent, complete article. The power of this architecture lies in its ability to handle tasks of almost any complexity, as long as they can be effectively decomposed.

The sixth is the evaluator-optimizer architecture, which improves output quality through continuous evaluation and optimization, similar to a simplified version of RLHF (Reinforcement Learning with Human Feedback). A generation agent creates initial content, which is then evaluated by an evaluator agent (typically using the best-performing LLM). If the results are unsatisfactory, the evaluator provides specific improvement suggestions, and the generation agent optimizes based on the feedback.Ahmad's example of an eco-friendly water bottle product description is very convincing: the first generated description was deemed by the evaluator agent to not effectively target the “environmentally conscious millennials” audience. The evaluator agent provided very specific improvement suggestions, including which features to emphasize and what tone to use. The second generated description was significantly more aligned with the target audience's needs and preferences.

The seventh is the tool calling architecture, which allows agents to seamlessly integrate with external systems and expand their capabilities. The eighth is the memory architecture, which is the document question-and-answer model we saw at the beginning of the presentation.

What impressed me the most was that Ahmad used CHAI to build several complex practical applications on the spot.He built a deep research agent similar to Perplexity, where the system automatically identifies the need for query analysis, performs web searches (using the Exa search tool), integrates results, and generates responses—all in pure JavaScript with no framework dependencies. He also demonstrated a receipt checker that automatically identified the absence of a ready-made OCR basic unit and integrated Mistral's OCR API, showcasing the basic unit system's strong extensibility.There is also an image analysis agent that can analyze the expressions and emotions of people in pictures. Ahmad uploaded a photo of himself, and the agent accurately described his expression as “eyebrows slightly raised, looking slightly skeptical and curious.”

Why basic units are the inevitable choice for the future

After gaining a deep understanding of Ahmad's ideas and practices, I began to think from a more macro perspective about the profound impact of this basic unit-based approach on the entire AI industry.I believe that we are undergoing a technological revolution similar to the transition from assembly language to high-level languages, but interestingly, the direction seems to be reversed: we are moving from excessive abstraction back to a more essential and controllable form of expression.

From a technological development perspective, the basic unit approach is consistent with the natural evolution of software systems. In the history of computer science, technologies that have stood the test of time often follow the design principle of “simple yet powerful.”Unix pipes and tools, the HTTP protocol, and the SQL language have been able to exist and evolve over time because they provide simple yet powerful basic units that developers can flexibly combine to solve complex problems. AI basic units continue this tradition, providing a stable infrastructure for the rapidly changing field of AI.

From a developer experience perspective, the basic unit approach significantly reduces the cognitive burden of AI development. Ahmad mentioned an important point in his speech:When most engineers are transitioning to AI engineering, they don't need another complex conceptual framework. Instead, they need to build AI applications using familiar tools and thinking patterns. Basic units perfectly address this need. A developer with JavaScript experience can immediately understand AI agent code based on basic units because it is essentially ordinary JavaScript code that calls some special APIs. This continuity is crucial for technology adoption and widespread application.

From the perspective of performance and scalability, the basic unit approach has significant advantages. Each basic unit can be optimized independently. For example, the Memory unit can focus on optimizing the performance of vector search, while the Parser unit can focus on the processing efficiency of various document formats. This division of labor allows the entire system to achieve higher performance levels. At the same time, the stateless design of basic units makes them naturally support horizontal scaling, enabling easy implementation of serverless architectures.Ahmad emphasized this point in his presentation: agents built using Langbase basic units can automatically scale to handle workloads ranging from a few requests to millions of requests.

From the perspective of business flexibility, the basic unit approach enables enterprises to respond more quickly to market changes and user needs. When new LLMs are released or new AI capabilities emerge, enterprises can rapidly integrate new technologies without needing to refactor the entire system. For example, if a better document parsing technology becomes available, you only need to replace the Parser basic unit, while the rest of the system remains completely unaffected. This modular design significantly reduces the risks and costs associated with technological iterations.

From a technical ecosystem perspective, the basic unit approach promotes true technical standardization. Unlike frameworks that attempt to standardize abstract layers (often leading to fragmentation), basic units standardize capability interfaces. This enables basic units from different vendors to be interchanged and combined, forming an open, competitive, and collaborative ecosystem. The Model Context Protocol (MCP) mentioned by Ahmad is an example of such standardization efforts.

I strongly agree with Ahmad's assessment of future trends: as LLMs become more intelligent in agent workflows, applications tied to specific framework abstractions will struggle to adapt quickly to new capabilities. Systems built on basic units, however, can more easily integrate new AI capabilities and workflows due to their underlying flexibility. This is akin to building a scalable instruction set architecture for the AI era, enabling upper-layer applications to evolve continuously without being constrained by underlying technological changes.

In the long run, I predict we will see a layered AI development ecosystem: at the bottom are high-performance, reliable basic unit services (such as Langbase, OpenAI API, Anthropic API, open lovable , etc.), in the middle are combination patterns and best practice libraries tailored to specific industries or scenarios, and at the top are application products for end users. This layered structure will maintain sufficient flexibility to adapt to technological changes while providing enough abstraction to simplify development work.

Ultimately, I believe that the basic unit approach represents a new technical philosophy: rather than attempting to predict and control the future, we should build infrastructure that is flexible and powerful enough to adapt to the myriad possibilities of the future. In this uncertain AI era, this may be precisely the technical paradigm we need most.As Ahmad concluded in his speech: Instead of using bloated frameworks to build agents, why not use basic units like building blocks to create your own “Agent Stack”? This is not just a technical choice but a forward-thinking strategic approach.