Meta's Forum app: shifting from human-in-the-loop to human-on-the-loop

Meta has released Forum, a standalone application designed to deepen engagement within Facebook Groups. To build this product, a small engineering team adopted a novel workflow that integrates AI agents directly into the development lifecycle. Published on October 15, 2026, their case study details how they moved beyond using AI as a simple coding assistant to treating it as an active participant in planning, building, and verification.

What happened

The core shift in Meta’s approach was moving from a "human-in-the-loop" model to a "human-on-the-loop" model. In the traditional human-in-the-loop setup, an engineer drives every step of development while AI assists with tasks like autocompletion or answering questions. The pace of work is limited by the speed of the individual developer. In contrast, the human-on-the-loop model allows the AI agent to run entire iterations independently. The agent plans, implements, builds, tests, corrects, and repeats cycles while the engineer sets high-level goals, monitors progress, and approves final results.

This change redefines the engineer’s role from executing steps to owning outcomes and maintaining quality standards. While not every stage is fully autonomous yet, the goal is to allow overlapping cycles where engineers focus on direction and judgment rather than waiting for sequential tasks to complete. Success was not measured by the volume of code generated, but by verified, production-ready outcomes. A task was only considered complete when it built successfully, passed automated tests, and survived review, ensuring that AI-generated code was trustworthy before reaching human eyes.

How it works

To make autonomous loops safe and effective, Meta implemented four key capabilities. First, planning became a rigorous technical specification process. Since agents lack human intuition, ambiguity leads to failure. The team invested in precise upstream decomposition and machine-readable context to guide the agent. Second, automated verification was integrated directly into the agent loop. Build status, unit tests, and UI spec matching provided immediate pass/fail signals, allowing the agent to self-correct before submitting work for review.

Third, the team deployed navigation agents that simulated real user behavior. These agents interacted with the live app, performing actions and reading screens to detect regressions continuously. Finally, agentic production operations were established to handle post-launch feedback. When users reported issues, agents investigated potential regressions and forwarded analysis to engineers for decision-making. This system relied on specific operating components: permanent rules to prevent repeated mistakes, skills that encoded team conventions, commands that chained workflows, and hooks that triggered automated checks like linting or test validation.

Key details

• Verification over compilation: Tasks are only complete after passing automated tests and visual checks, not just after compiling.
• Separate build flavor: A sandbox app shares the production codebase but excludes prototype code, preventing experimental features from crashing the live app.
• Tool-based context: Agents use tools to read live view hierarchies and check screen elements directly, reducing errors caused by guessing coordinates or screen states.
• Architectural legibility: The codebase was modularized and simplified to help agents understand patterns, trading some reuse for higher agentic throughput.
• Stress testing: Agents ran repeatable stress scenarios like aggressive scrolling and rapid navigation, catching a memory issue during development that halved memory use.
• Human oversight: Engineers retain final sign-off on all changes, supported by attached build results, test outcomes, and recorded verification sessions.

Why it matters

For software teams, this case study highlights that integrating AI effectively requires changing the environment and tooling, not just the prompts. Meta found that giving agents direct access to state-checking tools was far more effective than describing the app to them. By providing agents with the ability to read live view hierarchies and verify their own work, the team reduced misdirected edits and increased confidence in generated code. This suggests that future AI-native development will depend heavily on building robust verification infrastructure and clear architectural boundaries.

The impact on velocity and quality was significant. Forum reached core feature parity with Facebook Groups in just eight weeks, with AI handling routine implementation. More importantly, the continuous verification loop caught systemic issues early, such as a memory bottleneck that was identified and fixed before launch. This demonstrates that AI can do more than accelerate coding; it can tighten the quality loop, allowing small teams to deliver high-quality products with less rework and greater leverage.

What you can do

• Shift to outcome-based metrics: Measure success by verified, production-ready changes rather than lines of code or speed of generation.
• Integrate verification into the loop: Connect build status, unit tests, and UI checks directly to your AI agent so it can self-correct before human review.
• Provide direct state access: Give agents tools to query live system states, such as view hierarchies or database contents, instead of relying on static descriptions.
• Modularize for clarity: Simplify code architecture and break down complex modules to make patterns easier for agents to learn and follow.
• Implement sandboxed builds: Use separate build flavors or plugins to isolate experimental AI-generated code from production binaries.
• Automate stress testing: Set up agents to run repeatable user behavior simulations to catch regressions and performance issues during development.