Lina Hope
In the rapidly evolving landscape of software development, the role of Artificial Intelligence has largely been relegated to a productivity booster—a high-speed autocomplete tool designed to shave seconds off a developer’s typing time. However, a small engineering team at Meta recently challenged this paradigm. By developing "Forum," a standalone Groups application built from the ground up, the team sought to shift the focus from AI-assisted coding to agentic, autonomous engineering.
The project represents a fundamental transition from "Human-in-the-Loop"—where AI acts as a subordinate assistant—to "Human-on-the-Loop," where AI agents take ownership of the execution cycle, and engineers shift their focus to defining outcomes, maintaining quality bars, and supervising autonomous processes.
The Core Philosophy: Moving Beyond Code Volume
For the Forum team, the primary objective was never to maximize lines of code generated per hour. Instead, they focused on "verified, production-ready outcomes." The engineering philosophy centered on a simple truth: AI-generated code is only as valuable as the tests it passes.
In traditional AI coding setups, the "Human-in-the-Loop" model keeps the engineer tethered to every iteration. The developer must manually review, debug, and implement every suggestion. This often leads to a bottleneck where the human remains the primary executor, and the AI serves only as an accelerator for syntax.
By contrast, the "Human-on-the-Loop" approach empowers the agent to run the entire iteration: planning, implementation, building, testing, and error correction. The engineer’s role is elevated to that of an architect and supervisor. They set the high-level goals and step in only when the system drifts or requires a final sign-off. This creates an asynchronous workflow where the AI handles the repetitive, labor-intensive cycles, freeing the engineer to focus on complex decision-making and product judgment.
Chronology of the Forum Experiment
The development of Forum was not a linear progression, but a series of iterative experiments in agentic autonomy.
Phase 1: Establishing the Foundation
The team began by modularizing the architecture of the Forum application. They realized that agents learn patterns from the code they read; therefore, they prioritized architectural legibility. By choosing to build from scratch rather than inheriting legacy complexity, the team ensured that the agents could plug into a predictable, clean codebase.
Phase 2: Tooling and Contextual Awareness
Early iterations revealed a significant failure mode: agents often lost their place within the application’s UI hierarchy. To combat this, the team stopped providing descriptive prompts and started providing tools. They gave agents the ability to read the live view hierarchy from the simulator, list elements present on the screen, and calculate paths to target views. By allowing the agent to "see" the app’s state directly, misdirected edits dropped significantly.
Phase 3: The Sandbox Architecture
As the project neared production, the team needed a way to test agent-generated code without risking the stability of the live product. They implemented a "separate build flavor" system. This sandbox environment shared the same core codebase as the production app but utilized a plugin-socket architecture that completely excluded prototype code from the final production build. This provided a "safe-to-fail" environment where agents could experiment continuously.
Supporting Data and Technical Implementation
The success of the Forum project was built on four pillars of agentic execution:
- Planning as Technical Specification: The team discovered that agentic failure is often a result of ambiguity. By enforcing rigorous, machine-readable context in the planning phase, they forced the AI to operate with the precision of a compiler.
- Automated Verification as a Force Multiplier: Verification was treated as the ultimate gatekeeper. Agents were required to check their own work against automated build statuses and unit tests before any human review.
- Simulated User Testing: The team deployed "navigation agents" that mimicked real user interactions—scrolling, browsing, and media loading—to identify regressions in real-time.
- Agentic Production Operations: Post-launch, agents were tasked with analyzing user feedback and investigating potential regressions, which were then reported to engineers with structured, actionable insights.
The results were statistically significant. By prioritizing "verified outcomes" over "compiled code," the team saw a marked reduction in rework. The performance profile of Forum demonstrated superior memory management and fewer page faults compared to similar legacy apps, largely because the agents were capable of running continuous stress tests that identified systemic issues long before they reached the end-user.
Official Perspectives on the Shift
The engineering leads behind the Forum project have been clear: the gains did not come from better "prompt engineering." Instead, the gains came from changing the environment in which the models operate.
"We gave the agents tools to check state directly rather than descriptions to reason from," the team noted in their post-project debrief. By shifting the constraint from "writing code" to "verifying code," the team successfully moved the bottleneck. They emphasize that the goal is not to remove the human, but to change the nature of the human’s involvement.
The team acknowledges that some stages of the development cycle still require a human in every iteration. However, they argue that the "Human-on-the-Loop" model is the future of sustainable, high-velocity engineering. By training the AI with comprehensive design documents and code pointers—the same way a human employee is onboarded—they achieved a level of consistency that ensures every future agent session builds upon the last, rather than starting from scratch.
Implications for the Software Industry
The Forum experiment provides a roadmap for the future of software engineering, carrying several profound implications:
1. The Death of the "Plausible Output" Trap
One of the most dangerous traps in AI coding is the generation of code that looks correct but is functionally flawed. By mandating that agents verify their own work, the Forum team eliminated the "review fatigue" that often plagues senior engineers when dealing with AI-generated pull requests. The output is now smaller, but significantly higher in confidence.
2. Architectural Legibility as a Prerequisite for AI
Companies that cling to legacy, spaghetti-code architectures may find it difficult to adopt agentic workflows. Forum demonstrates that for AI to function effectively, the codebase must be legible. Companies will likely begin refactoring their existing systems specifically to make them "AI-readable" to leverage these autonomous tools.
3. The New Role of the Engineer
If the agent is doing the "mechanical" work of coding, testing, and debugging, the role of the engineer shifts toward Product Ownership and Quality Assurance. Future engineers will likely spend more time writing "technical specifications" and "verification harnesses" than they will writing individual classes or functions.
4. Continuous, Autonomous Stress Testing
The most transformative aspect of the Forum project was using the agent not just as a developer, but as a relentless tester. By automating the "reproduce-isolate-fix-verify" cycle, the team created a self-healing system that caught memory leaks and performance regressions that might have been overlooked by humans during the fast-paced development cycle.
Conclusion
The Forum project stands as a testament to the fact that AI is most powerful when it is integrated into the infrastructure of a product, rather than being treated as an external plugin. By building an environment that supports, verifies, and constrains agentic behavior, the team at Meta has provided a compelling glimpse into the future of software development. As organizations look to scale their engineering teams, the shift from "Human-in-the-Loop" to "Human-on-the-Loop" appears not just as a potential upgrade, but as an eventual necessity for maintaining code quality in an AI-driven world.
Jia Lissa
Nila Kartika Wati
Raul Delapena Setiawan
Reynand Wu
Sagoh
Azzam Bilal Chamdy
Ali Ikhwan