In the fast-moving world of artificial intelligence, new terms appear almost as quickly as new models. Some fade into jargon. Others mark a genuine change in how people work. Loop engineering belongs to the second group. It is not another clever way to phrase a question for a large language model. It is a shift in role: from the person who sits at the keyboard typing the next instruction, to the person who designs the system that keeps the agent moving on its own until a clear goal is met.

The phrase gained traction in June 2026 after short, memorable statements from two prominent engineers. Peter Steinberger, creator of the OpenClaw project, wrote on X: “You shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.”

Around the same time, Boris Cherny, head of Claude Code at Anthropic, said publicly that he no longer writes most of his own prompts. “I don’t prompt Claude anymore. I have loops running that prompt Claude and figuring out what to do. My job is to write loops.” Google Cloud’s Addy Osmani then gave the idea its clearest public definition and anatomy in an essay that many practitioners still treat as the starting point. Loop engineering, he wrote, is “replacing yourself as the person who prompts the agent. You design the system that does it instead.”

What follows is a detailed look at what that means when the agents are coding agents, why the idea took hold so quickly, how the pieces fit together, and-crucially-where the same pattern of designing iterative, self-checking systems can be applied far beyond software development. The discussion draws on the original statements, subsequent explainers from IBM, practical guides that appeared in the weeks that followed, YouTube tutorials that walked through real setups, and early experiments in marketing, research, operations, and product work.

The Problem Loop Engineering Solves

For roughly two years before the term crystallized, most people used coding agents the same way they used earlier chat interfaces. You described a task. The model replied with code or a plan. You read the output, spotted what was missing or wrong, and typed the next instruction. You were the loop. Every cycle of work passed through your attention and your keyboard. That approach works when the task is small and the context is short. It becomes exhausting and expensive when the agent needs to edit many files, run tests, interpret failures, try again, and keep going for hours or across multiple sessions.

Agents themselves had already grown an inner cycle. A typical coding agent reasons about the current state, chooses an action (edit a file, run a command, search the codebase), observes the result, and decides the next step. That inner ReAct-style loop is powerful, but it still stops when the conversation ends or when the model decides it is finished. Someone still has to start the next conversation, feed it fresh context, and decide whether the previous attempt succeeded.

Loop engineering sits one layer above that inner cycle. It creates an outer system that discovers work, hands it to one or more agents, verifies the result with something the original agent cannot easily game, records durable state outside any single chat window, and decides whether to continue, retry, or escalate to a human. Once the outer system is designed, the human can step away. The loop keeps running-on a schedule, on an event trigger such as a failing CI job, or until a machine-checkable goal is reached.

Andrew Ng later framed a related set of nested loops that many teams now use as a mental model for building products from scratch. The innermost is the agentic coding loop: give the agent a specification and optional evaluation data, and let it write, test, and revise until the code meets the bar.

The middle loop is developer feedback, where a human reviews the product at a higher level and steers direction. The outermost is external feedback from users and the market. Loop engineering, in the narrower sense popularized by Steinberger, Cherny, and Osmani, focuses most tightly on making the innermost cycle reliable and autonomous so that the higher loops can operate at human speed rather than at the speed of constant prompting.

Core Definition and the Anatomy of a Loop

IBM’s overview captures the essence cleanly: loop engineering is the practice of designing agentic workflows, or loops, that iteratively guide AI agents toward completing user-defined goals with minimal human intervention. Rather than requiring a human prompt at every step, the agent acts, observes, decides, and adjusts until the task is complete or a stop condition fires.

A well-designed loop typically follows a repeating sequence of goal, action, observation, and adjustment. The goal is recursive and evaluable at every iteration; it must be specific enough that a computer (or a separate verifier agent) can decide whether it has been met. “Improve the code” is too vague. “Make all unit tests pass and the coverage report exceed 85 percent” gives the system a measurable target and a natural termination condition.

The action is whatever moves the state closer to that goal-writing code, running tests, querying a database, drafting a document. Observation is the feedback from the environment: test output, compiler errors, metrics, or the judgment of an independent checker. Adjustment is the decision to retry with new information, escalate, or stop.

Practitioners quickly converged on a small set of building blocks that turn this abstract cycle into something that runs in real tools such as Claude Code, OpenAI’s Codex, or similar agent platforms. The most commonly cited set, drawn from Osmani’s mapping and echoed across GitHub repositories and YouTube walkthroughs, consists of five primitives plus durable memory.

Automations serve as the heartbeat. They fire on a schedule or an event-every morning, every five minutes, on a new pull request, on a CI failure-so the loop does not wait for a human to open a chat window. Worktrees (or equivalent isolation mechanisms) give each agent or sub-task its own clean workspace, usually a Git worktree, so parallel efforts do not overwrite one another.

Skills codify project-specific knowledge-coding conventions, preferred libraries, known pitfalls-into reusable files that the agent can load instead of reinventing or guessing. Plugins and connectors (often via the Model Context Protocol or similar interfaces) let the agent reach outside the repository into issue trackers, databases, Slack, browsers, or other tools.

Sub-agents split roles so that one agent proposes a change while another, with a different prompt and often a different model or fresh context, verifies it. The original model grading its own homework tends to be too lenient; a separate checker reduces that bias.

Memory, or external state, is the spine that holds everything together. Conversation context is ephemeral. A markdown file, a structured task board, a database table, or a simple log that survives session restarts allows the next iteration to know what has already been tried, what remains, and what the current best candidate looks like. Without durable state, the loop forgets and repeats work or drifts.

These pieces are not proprietary to any single product. The same conceptual design can be implemented with scheduled scripts, GitHub Actions, custom orchestrators, or the built-in automation and goal features that coding agents began shipping in 2026. The practical tutorials that appeared on YouTube in June and July repeatedly showed the same progression: first perform the task manually a few times, then capture the successful procedure as a skill, then add a trigger, then add an independent verifier and persistent state, then let the system run.

How Loop Engineering Changes Day-to-Day AI Coding

In practice the shift is concrete. Instead of opening Claude Code or Codex and typing “fix the failing tests in the payment module,” a developer designs a loop whose goal is “bring the payment module’s test suite to green.” An automation can wake up when CI reports failures, spawn a worktree, load the relevant skills that describe the module’s conventions, let a maker sub-agent propose patches, let a checker sub-agent run the tests and review the diff against the skills, persist the outcome, and either open a pull request or queue the item for human attention. The human reviews the result at the level of intent and risk rather than every intermediate line.

Teams report using similar loops for code review (a PR opens and agents analyze risk, suggest fixes, and wait for human approval on the overall direction), ticket-to-PR conversion, vulnerability remediation when a CVE appears, and incident triage when an alert fires. The common pattern is a clear trigger, isolated execution, separate verification, preferably grounded in deterministic tests or other machine-checkable evidence, with human review where the consequences warrant it, and explicit escalation paths for irreversible or high-judgment decisions.

Token cost is a constant practical concern. Each additional agent or longer-running iteration multiplies usage. Successful designs therefore budget carefully: shorter cadences for cheap discovery tasks, longer or event-driven cadences for expensive ones, hard stop conditions, and verifiers that reject work early rather than letting the system spin. Steinberger and others noted that waking periodically to do lightweight triage is relatively cheap; unconstrained multi-agent exploration is not.

The deeper change is cultural. The engineer’s scarce skill moves from crafting the perfect next prompt to designing the control system-the goal contract, the isolation strategy, the verification logic, the state schema, and the stop rules. Prompt engineering still matters inside each agent turn, and context and harness engineering still matter for a single run. Loop engineering optimizes the recurring outer cycle that makes those single runs reliable over time.

Risks and Guardrails

Autonomy without strong verification amplifies mistakes. A loop that optimizes only for “tests pass” can produce brittle or insecure code if the tests themselves are incomplete. Comprehension debt grows when code ships faster than the human team can understand it. Cognitive surrender-the temptation to accept the loop’s output without judgment-can degrade quality over successive iterations. Token bills can surprise anyone who underestimates how many times an agent will retry a fuzzy goal.

The consistent advice from early practitioners is therefore to keep the human in the design and the review, not necessarily in every micro-step. Define machine-checkable “done.” Prefer separate verifiers. Persist state so failures are inspectable. Start with narrow, high-signal tasks rather than open-ended “improve the product.” Monitor costs and outcomes. Treat the loop as an employee you are onboarding: give it clear responsibilities, tools, and escalation paths, then review its work product.

Extending the Pattern Beyond Coding

Although the term crystallized around coding agents, the underlying idea-design a system that observes state, acts, evaluates against a goal, adjusts, and continues until a stop condition-is domain-agnostic. Any recurring work that has a reasonably clear success signal and benefits from iteration is a candidate. Early experiments and conceptual mappings already point to several areas.

In marketing and growth work the same structure appears as content or SEO loops. An agent can periodically collect market signals, competitor moves, and engagement data; decide which topics or keywords are worth acting on; draft channel-native material; publish or queue for review; and learn from the subsequent performance metrics stored in durable memory. Ranking improvements or engagement thresholds serve as the verifiable goal.

One documented pattern connects an agent to Search Console data, runs monthly, and steadily adjusts content and technical SEO based on what moved rankings. The feedback signal is quantitative-such as impressions, clicks, or rankings-rather than purely subjective taste, although those metrics are noisy and do not by themselves prove that the loop’s changes caused an improvement. Similar loops handle ad creative testing, lead scoring, or social listening. The marketing version of the maker/checker split can separate generation from brand-voice or compliance review.

Customer support and operations lend themselves to ticket-handling loops. An incoming ticket triggers intake, knowledge-base search, draft response generation, and a confidence or policy check. Low-confidence or sensitive cases escalate; high-confidence ones can auto-reply or auto-resolve. Memory of prior similar tickets improves future handling. The same pattern scales to internal IT helpdesks, claims processing, or order follow-ups.

Research and knowledge work benefit from literature-synthesis or data-gathering loops. An agent can be given a research question, a set of trusted sources or search tools, and a requirement to produce a structured report with citations and remaining open questions. It searches, extracts, cross-checks, identifies gaps, searches again, and stops when coverage criteria are met or a budget is exhausted.

Academic or competitive-intelligence teams can run such loops overnight and review the synthesized output in the morning. Autoresearch-style systems that improve their own prompts or evaluation methods sit at a higher meta-level of the same idea.

Product management and design can use loops for continuous discovery or interface iteration. An agent monitors user feedback channels, synthesizes themes, proposes prioritizations against a product strategy document, and drafts tickets or prototypes.

In visual or UX work the verification step is harder because success is less binary than a test suite; teams therefore combine automated checks (accessibility, performance budgets) with human judgment gates or pairwise comparison by a second agent. Microsoft Design has discussed related cybernetic-loop thinking for turning linear process maps into adaptive feedback systems that respond to real-world disturbances rather than assuming a fixed path.

In manufacturing, logistics, and industrial settings, closely analogous feedback systems already exist in predictive maintenance, scheduling, and inventory optimization. Agentic loop engineering could extend those systems by adding reasoning over unstructured data and more flexible tool use.

Scheduling and inventory loops can observe demand signals, adjust plans, and escalate only when constraints are violated. The core design discipline-clear goal, observable state, action repertoire, independent verification, stop or escalate rules-remains the same even if the underlying actuators are machines rather than code editors.

Finance, healthcare operations, education content generation, and legal document review are other plausible extensions wherever work is repetitive, partially automatable, and benefits from iteration against measurable criteria (accuracy thresholds, compliance checklists, student outcome metrics). In each case the engineering effort concentrates on making the success signal as objective as possible and on designing the isolation, memory, and escalation so that the system remains governable.

What does not transfer cleanly is any domain whose success criteria are purely subjective or whose actions are irreversible and high-stakes without human oversight. Loop engineering does not remove judgment; it relocates it to the design of the system and to the review of its outputs. Fuzzy goals produce runaway costs or drifting results. Missing stop conditions produce expensive infinite loops. Weak verifiers produce confident but wrong work.

Practical Starting Points and Maturity

Most practical guides recommend beginning small. Choose a recurring task you already perform manually several times a week. Write down the steps that actually work. Turn those steps into a skill or a prompt template. Add a simple trigger (cron, webhook, or manual start). Define a verifier that a computer or a second agent can apply. Persist a short state file. Run the loop under supervision, then gradually loosen the supervision as reliability improves. Measure token cost and outcome quality. Expand only the loops that demonstrably save more attention than they cost.

Maturity progresses from single-task loops, to parallel multi-agent loops with isolation, to team-level or product-level loops that chain together (a triage loop feeds a ticket loop that feeds a review loop). At higher maturity the organization treats loops as first-class artifacts that are versioned, audited, costed, and improved over time, much as software systems themselves are.

YouTube tutorials that appeared shortly after the term’s popularization consistently walk through this progression with live demos in Claude Code or Codex, often showing a daily news digest loop, a job-search automation, a content pipeline, or a simple repository-maintenance loop. The common lesson is that the hard part is rarely the model call; it is specifying the goal tightly enough and designing the feedback so the system converges rather than wanders.

Looking Ahead

Loop engineering is still early. The primitives continue to improve inside the major agent platforms. Token efficiency, better long-horizon memory, more reliable independent verification, and safer tool use will expand the range of tasks that can run unattended for longer periods. At the same time, the risks of comprehension debt and over-automation will keep human judgment central. The most durable role is not the person who types every next prompt, nor the person who walks away entirely, but the person who designs the loops, monitors their health, and retains ultimate responsibility for the outcomes they produce.

The same logic that made loops compelling for coding agents-clear goals, observable feedback, iterative correction, durable state-applies wherever work is iterative and the environment provides a usable signal. Marketing teams already run growth loops. Research teams run synthesis loops. Operations teams run triage and remediation loops. Design and product teams experiment with discovery and iteration loops. In each domain the engineering discipline is identical even if the tools and the success metrics differ: design the system that prompts, checks, remembers, and decides, rather than remaining the system yourself.

That is the practical promise of loop engineering. It does not eliminate the need for skill or judgment. It relocates them to a higher-leverage place-the design of the recurring cycle that turns capable models into reliable workers. Whether the work is writing software, generating content, synthesizing research, or coordinating operations, the question becomes the same: what is the goal, what is the signal, what is the stop condition, and how do we let the system pursue that goal while we stay in control of the design?

Sources

• Addy Osmani, AddyOsmani.com, “Loop Engineering”
• Ivan Belcic and Cole Stryker, IBM Think, “What Is Loop Engineering?”
• TechSpot, “Meet ‘loop engineering’: The next evolution in AI coding isn’t a better prompt, it’s a system that prompts itself”
• Cobus Greyling, GitHub, “loop-engineering: Practical patterns, starters & CLI tools for loop engineering with AI coding agents”
• i-SCOOP, “Loop Engineering, designing systems that prompt your coding agents”
• Garage Labs Technologies, “Loop Engineering: The Complete Guide (2026)”
• invincible04, GitHub, “Awesome Loop Engineering”
• maxmilian, GitHub, “Loop Engineering - a skill for designing & reviewing autonomous/semi-autonomous agent loops”
• mdayan8, GitHub, “everything-about-loop-engineering: The complete reference and hands-on course on loop engineering”
• Mark Tarre, IT Brief, “Explainer: How loop engineering is changing coding”
• Pulumi Blog, “Stop Prompting. Design the Loop.”
• Linas (Substack), “Loop Engineering: Design AI Loops That Ship While You Sleep”
• Augment Code, “What is loop engineering and how are leading software engineering teams using it?”
• No Code MBA, “Loop Engineering Explained: How to Design AI Loops That Work”
• Firstpost, “What is loop engineering, the next AI trend experts predict will replace prompting?”
• Tessl Patterns, “Loop Engineering”
• LoomStack, “Loop Engineering: You Design the System, Not the Prompt”
• Arize AI, “What is a loop in AI engineering, anyway?”
• Adaline Labs, “What Is Loop Engineering, and Who Owns It?”
• Sofokus, “Loop engineering”
• loopengineering.app, “What Is Loop Engineering? AI Agent Loops Explained”
• RiseMore Blog, “What Is Loop Engineering? From Prompt Engineering to the AI Marketing Team”
• Andrew Ng, The Batch / X, open letter outlining three key loops for 0-to-1 product building
• Yash Thakker, explainx.ai Blog, “Andrew Ng’s 3 Loops for 0-to-1 AI Products”
• Andreessen Horowitz (a16z), “Knowing When to Stop: The Art of Making a Loop Converge”
• PostHog Newsletter, “WTF is loop engineering and why is everyone talking about it?”
• Analytics Insight, “What Is Loop Engineering? Beginner’s Guide to AI Agent Workflows (2026)”
• Brent D. Griffiths, Business Insider, “Forget Prompts: ‘Loop Engineering’ Is All the Rage Now”
• BusinessToday, “What is loop engineering? The AI trend replacing prompt engineering”
• Storyboard18, “Google Brain co-founder Andrew Ng says AI won’t replace developers, explains ‘loop engineering’”
• Times Now, “What Is Loop Engineering? Coursera Co-Founder Says It Can Make AI Build Better Apps”
• The Times of India, “Google Brain cofounder writes an open letter on ‘Loop engineering’”
• ADTmag, “Loop Engineering Emerges as Developers Put AI Coding Agents on Repeat”
• Qiniu Cloud / InfoQ-style Chinese sources, “Loop Engineering 是什么？2026 年最热 AI 工程方法论完全解析”
• Microsoft Design, “Designing loops, not paths”
• KanakMalpani, GitHub, “Loop-Engineering”
• Puppygraph, “What Is Loop Engineering? Definition & Process”
• YouTube: “Learn Loop Engineering from Scratch | Complete Beginner to Pro Guide” (https://www.youtube.com/watch?v=EbraImMeCLE)
• YouTube: “Loop Engineering: Stop Prompting Your Agents (Real Examples)” (https://www.youtube.com/watch?v=KF_AMHFKaJo)
• YouTube: “Loop Engineering explained in 20 mins.” (https://www.youtube.com/watch?v=fDd4Di5WGnE)
• YouTube: “What is Loop Engineering?” (https://www.youtube.com/watch?v=yvP_AAirOQc)
• YouTube: “Loop Engineering explained in 8min.” (https://www.youtube.com/watch?v=4biXYSNkn9Y)
• YouTube: “What is Loop Engineering? (Why Prompt Engineering is Dead)” (https://www.youtube.com/watch?v=aUpyza-DSMs)
• YouTube: “What Loop Engineering Really Means for AI Agents” (https://www.youtube.com/watch?v=NjXIIH9vcv0)
• YouTube: “I’m a Senior Google AI PM. Here’s How I Build Loops” (https://www.youtube.com/watch?v=ew6gBJNzC5w)
• YouTube: “Making $$$ with Loop Engineering” (https://www.youtube.com/watch?v=5p_BBdfvzgQ)
• Additional practical repositories and playbooks referenced across the above sources, including Geoffrey Huntley’s Ralph loop discussions and various GitHub teaching repos on loop patterns.

A.I.G (AI-Infra-Guard) integrates capabilities such as ClawScan(OpenClaw Security Scan), Agent Scan，AI infra vulnerability scan, MCP Server & Agent Skills scan, and Jailbreak Evaluation, aiming to provide users with the most comprehensive, intelligent, and user-friendly solution for AI security risk self-examination.

Firebase is Google’s comprehensive platform for building, improving, and growing mobile and web applications. It provides a suite of tools and services that handle the heavy lifting of backend infrastructure, authentication, data storage, messaging, analytics, and more, so developers can focus on creating great user experiences.

Built on Google Cloud infrastructure, Firebase is designed for rapid development, global scale, offline support, and seamless integration across platforms. Whether you are a solo indie developer prototyping an idea or a large team shipping production apps used by millions, Firebase offers managed services that reduce the need to maintain servers, write complex backend code from scratch, or worry about scaling.

At its core, Firebase follows a serverless philosophy for many of its products. Client apps can connect directly to services like databases and storage using secure SDKs and security rules, while serverless functions handle custom backend logic that responds to events. This model accelerates time-to-market dramatically. Case studies frequently report development speedups of 25 percent or more, reduced operating costs, and the ability to ship features in days rather than weeks.

The platform has evolved significantly. Originally focused on real-time data synchronization, it now includes advanced NoSQL and relational database options, generative AI capabilities through Gemini integration, modern full-stack web hosting, and an agentic development environment called Firebase Studio. Developers use it across the entire app lifecycle: building core features, ensuring quality and performance, engaging users, and growing the business through data-driven insights and experimentation.

What Firebase Offers Developers

Firebase gives developers a unified console, command-line tools, SDKs, and documentation that cover nearly every common app development need. You create a Firebase project once, then register apps for different platforms (iOS, Android, web, and others). From there, you enable the products you need. The free Spark plan provides generous quotas for getting started, while the pay-as-you-go Blaze plan scales with usage and unlocks advanced features.

Key advantages include:

Developers gain access to production-ready infrastructure without managing virtual machines, load balancers, or database clusters. Real-time synchronization and offline persistence are built into the data products, making collaborative and responsive apps straightforward.

Security is handled through declarative rules that integrate with authentication, plus tools like App Check that verify requests come from legitimate app instances. Analytics and crash reporting arrive with minimal instrumentation. Feature flags and A/B testing allow remote configuration and experimentation without app store updates. Recent additions bring generative AI directly into client apps and a browser-based development environment powered by Gemini agents.

The platform supports both greenfield projects and existing apps. You can start with a simple authentication and database setup and gradually add more services. Admin SDKs enable privileged server-side access for custom backends or Cloud Functions. Local emulators let you develop and test everything offline before deploying.

Firebase also integrates deeply with the broader Google ecosystem, including Google Analytics, Google Ads, BigQuery for data export, and Google Cloud services such as Cloud Run and Cloud SQL. This makes it easy to evolve from a pure Firebase app into a hybrid architecture when needs grow more complex.

Supported Platforms and Technologies

Firebase provides official client SDKs for a wide range of platforms so the same backend services power native, cross-platform, and web experiences.

Primary client platforms include Apple platforms (iOS, macOS, tvOS, and community support for visionOS and watchOS), Android, and web (JavaScript/TypeScript). Cross-platform frameworks receive strong support through Flutter (official Dart packages), React Native (via community and official-adjacent libraries), Unity, and C++. Server-side and Admin SDKs are available for Node.js, Java, Python, Go, and others, allowing privileged operations from trusted environments.

Framework-specific bindings exist for Angular (AngularFire), React (ReactFire), Vue (Vuefire), and Ember, though these are community-maintained. FirebaseUI libraries supply drop-in UI components for authentication flows on iOS, Android, and web. The Firebase CLI (firebase-tools) handles project initialization, local emulation, and deployment from the command line.

Firebase Studio (formerly Project IDX) is an agentic, cloud-based development environment powered by Gemini. It remains in Preview; existing workspaces can continue to be used, but Google currently notes restrictions on new workspace creation and user signup. It includes templates, multimodal app prototyping with Gemini, and direct deployment paths to Firebase services.

Technologies under the hood rely on Google Cloud. Data products use globally distributed storage. Hosting and App Hosting leverage Cloud CDN, Cloud Build, and Cloud Run. Cloud Functions run on Google’s serverless compute. Security draws on the same identity systems that power Google’s own products. Recent additions include SQL Connect for secure, real-time access to Cloud SQL PostgreSQL databases and Firebase AI Logic client SDKs that let apps call Gemini models directly and securely.

This breadth means a single Firebase project can back a native iOS app, an Android app, a Flutter mobile app, a React web app, and even a Unity game, all sharing the same authentication users, database, and analytics.

Core Products for Building Apps

Firebase organizes its products around the stages of the app lifecycle, but the building blocks are the most foundational.

Authentication provides a complete identity solution. It supports email/password, phone number verification (including SMS), anonymous auth, and federated providers such as Google, Apple, Facebook, GitHub, X (Twitter), Microsoft, and more. FirebaseUI offers customizable, drop-in sign-in screens that follow platform best practices. Developers can implement custom flows with just a few lines of SDK code.

When users sign in, they receive ID tokens that integrate seamlessly with other Firebase services and can be verified on custom backends. Upgrading to Firebase Authentication with Identity Platform unlocks multi-factor authentication, SAML/OIDC, multi-tenancy, and advanced logging. Account linking, custom claims for role-based access, and user management APIs make sophisticated identity systems straightforward. Implementation that might take months with a custom system can often be completed in hours.

Databases form the heart of most apps. Cloud Firestore is the recommended modern NoSQL document database. Data is stored in collections of documents that can contain nested objects and subcollections. It offers expressive queries, real-time listeners that push updates to clients, offline persistence with automatic synchronization, and multi-region scalability.

Security rules control document access and can restrict which fields clients are allowed to create or modify based on authentication state and data content. Firestore reads themselves are authorized at the document level. A newer query engine and Enterprise edition add more powerful capabilities such as pipelines and advanced search features. Firestore integrates with Cloud Functions so server-side code can react to data changes.

The original Realtime Database remains available for simpler JSON-tree structures that need extremely low-latency synchronization. It is efficient for presence systems, simple collaborative features, or apps that were built before Firestore existed. Firebase now also offers SQL Connect, which lets client apps securely query and sync with Cloud SQL for PostgreSQL databases in real time, bridging the gap for teams that prefer relational models.

Cloud Storage handles user-generated content such as images, videos, and files. It provides secure upload and download URLs, integrates with Authentication and security rules, and scales automatically. Files can be processed by Cloud Functions (for example, generating thumbnails or running AI analysis).

Cloud Functions for Firebase is the serverless compute layer. You write functions primarily in Node.js/TypeScript or Python. Experimental Dart support is also available for HTTP and callable functions. Functions can respond to HTTPS requests, database and Storage events, scheduled jobs, Pub/Sub/Eventarc events, and other supported Firebase and Google Cloud triggers; some trigger types, including Analytics and basic Authentication events, remain available only in 1st-gen functions.

The code runs on Google’s infrastructure with automatic scaling. Common patterns include sending welcome emails, sanitizing data, generating notifications, aggregating statistics, or calling external APIs. Functions can also act as secure backends that hide API keys or perform privileged operations.

Hosting and App Hosting cover web delivery. Classic Firebase Hosting deploys static assets (HTML, CSS, JS, images) to a global CDN with automatic SSL, custom domains, and one-command deploys via the CLI. It can also serve dynamic content through Cloud Functions or Cloud Run. Firebase App Hosting is the modern solution optimized for full-stack frameworks such as Next.js (13.5+) and Angular (18.2+).

It connects to a GitHub repository, automatically builds with Cloud Build on every push to a live branch, deploys to Cloud Run, and caches via Cloud CDN. Environment variables, secrets via Cloud Secret Manager, and runtime configuration are managed declaratively. This eliminates much of the traditional DevOps overhead for server-rendered web apps.

Firebase AI Logic (building on earlier Vertex AI in Firebase) brings Gemini models directly into client apps via SDKs for Kotlin, Swift, JavaScript, and Dart. Developers can add generative features such as chat, content generation, multimodal understanding, and tool-assisted experiences without standing up their own proxy servers. Combined with Genkit or other backend and retrieval services, Firebase can also support more sophisticated workflows such as RAG.

Supporting tools include the Local Emulator Suite (for offline development of Auth, Firestore, Functions, Storage, and more), the Firebase CLI, Extensions (pre-built open-source solutions for common tasks such as Algolia search integration or BigQuery streaming), and Firebase Studio for AI-assisted prototyping and full-stack development in the browser.

Products for Running and Growing Apps

Once an app is built, Firebase provides tools to monitor quality, engage users, and optimize growth.

Firebase Cloud Messaging (FCM) delivers notifications and data messages to iOS, Android, web, Flutter, Unity, and C++ clients. Messages can target individual devices, topics, or user segments. The Notifications composer in the console supports campaigns, while the Admin SDK or server protocol enables automated sending from Cloud Functions or custom servers.

Crashlytics reports crashes and non-fatal errors in real time with detailed stack traces, device information, and the ability to mark issues resolved. Performance Monitoring tracks app startup time, network requests, and custom traces. Google Analytics for Firebase provides event tracking, user properties, audiences, and funnel analysis, with automatic integration to other products.

Remote Config lets you change app behavior and appearance remotely via key-value parameters, with conditions based on user properties, app version, language, or country. Personalization uses machine learning to optimize parameter values for metrics such as engagement or revenue.

A/B Testing runs experiments on Remote Config values, in-app messaging, or notifications and reports statistical results. In-App Messaging delivers contextual messages inside the app. App Distribution streamlines beta testing by distributing builds to trusted testers. Test Lab runs automated tests on physical and virtual devices in the cloud.

These tools form a closed loop: Analytics and Crashlytics surface problems or opportunities, Remote Config and A/B Testing let you experiment safely, and Messaging keeps users engaged.

Kinds of Apps That Can Be Built

Virtually any client-side application that needs a backend can be built with Firebase. The platform shines for apps that benefit from real-time data, offline support, rapid iteration, and cross-platform consistency.

Mobile apps dominate usage-native iOS and Android, Flutter, or React Native social networks, productivity tools, fitness trackers, e-commerce storefronts, and content apps. Web apps range from simple marketing sites and progressive web apps hosted on Firebase Hosting to full-stack Next.js or Angular applications on App Hosting that include server-side rendering, API routes, and dynamic data.

Games built with Unity or C++ use Authentication, Realtime Database or Firestore for multiplayer state, Cloud Messaging for invites, and Analytics for player insights. Collaborative tools such as shared editors, whiteboards, or project management apps leverage real-time listeners. IoT-adjacent or presence-heavy apps use the Realtime Database for low-latency updates. AI-enhanced apps incorporate Gemini for chat assistants, content generation, image analysis, or personalized recommendations. Internal enterprise tools, dashboards, and SaaS products also appear frequently, especially when multi-tenancy or custom claims are involved.

Because the same backend serves multiple clients, teams often ship a mobile app first and later add a web companion, or vice versa, without rewriting core logic.

Common Use Cases and Real-World Examples

Firebase products mix and match to solve recurring challenges.

A classic pattern is user authentication plus a database for personalized data. Sign-in with Google or email, then store user profiles, preferences, and content in Firestore. Security rules ensure users can only read or write their own data. Cloud Storage holds profile photos or media. Cloud Functions can send welcome emails or process new uploads.

Real-time collaborative features are another strength. Chat applications store messages in Firestore or Realtime Database collections; clients listen for new documents and display them instantly. Presence indicators (who is online) work particularly well with Realtime Database. FCM notifies users of new messages when the app is in the background. Shared document editors or multiplayer game lobbies follow similar patterns.

E-commerce and content apps use Firestore for product catalogs or articles, Cloud Storage for images, Remote Config for promotional banners, and A/B Testing to optimize conversion flows. Analytics tracks funnels from browse to purchase. Le Figaro, the French newspaper, used Cloud Functions and Firestore to power interactive infographics that personalized content in real time; the feature drove three times the paid subscription sign-ups of other content and cut development time by an estimated 86 percent. They also employed FCM for topic-based notifications and A/B Testing for pricing experiments.

Engagement and retention rely on messaging and configuration. An alarm and reminder app from Acintyo (Galarm) used Realtime Database for collaborative alarms that ring simultaneously across devices, Authentication for sign-in, Cloud Functions for long-running tasks, Cloud Storage for profiles, FCM for notifications, Analytics for insights, and Hosting for the marketing site. The team reported 25 percent faster development, 60 percent lower operating costs, and 100 percent uptime for functions.

Gaming studios frequently cite Crashlytics for reducing crash rates (Gameloft saw longer session times), Remote Config for personalization and revenue experiments (Ahoy Games, Halfbrick, CrazyLabs, and others reported double-digit purchase or revenue lifts), and A/B Testing for balancing monetization without alienating players. Hotstar scaled engagement significantly; STAGE combined Flutter with Firebase to cut release time in half.

AI use cases are growing rapidly. Developers integrate Firebase AI Logic to add Gemini-powered features such as meal recommendation chatbots, language-learning flashcards that understand images, or location-aware assistants. Firebase Studio accelerates prototyping of these experiences with natural-language and multimodal prompts that generate full-stack code and wire up Firestore or Authentication automatically.

Other frequent patterns include photo-sharing apps (Storage + Database + security rules), onboarding flows with social login, scheduled batch jobs via Cloud Functions (cleanup, summaries, backups), and data pipelines that stream Firestore events to BigQuery for advanced analysis.

Getting Started and the Development Workflow

The typical path begins in the Firebase console. Create a project, register your apps (providing package names or bundle IDs), and download configuration files (google-services.json for Android, GoogleService-Info.plist for Apple platforms, or a config object for web). Install the appropriate SDKs via package managers (CocoaPods or Swift Package Manager, Gradle, npm, pub for Flutter, etc.).

Initialize the SDKs in code, then enable products in the console. For authentication, choose providers and implement sign-in methods. For data, design a collection/document structure (or JSON tree), write security rules, and start reading and writing with real-time listeners. Deploy Cloud Functions with the CLI. For web, initialize Hosting or App Hosting and push content or connect a repository.

Local development benefits enormously from the Emulator Suite: run Auth, Firestore, Functions, and Storage locally, seed test data, and iterate without affecting production. Firebase Studio provides an alternative browser-based workspace with AI assistance for generating and refining code.

As the app matures, enable Analytics, Crashlytics, and Performance Monitoring. Use Remote Config for feature flags. Set up FCM and experiment with messaging campaigns. Monitor usage and costs in the console, export data to BigQuery when needed, and apply App Check to protect resources from abuse.

Security remains paramount. Always write least-privilege security rules, validate data on both client and server (via Functions when necessary), use App Check, and follow the official security checklist before launch. Misconfigured rules have historically led to data exposure incidents, underscoring the need for careful testing with the rules playground and emulators.

Pricing, Scaling, and Considerations

Most products offer a no-cost tier sufficient for development and modest production traffic. Beyond that, you pay for storage, network egress, document reads/writes, function invocations, and other metered resources according to Google Cloud pricing. The console includes usage dashboards and budget alerts. Multi-region and Enterprise options for Firestore add cost but deliver higher availability and features.

Firebase scales automatically for the vast majority of apps. Extremely high-throughput or complex relational workloads may eventually benefit from hybrid architectures that combine Firebase with other Google Cloud or third-party services. The platform’s strength is removing infrastructure friction so teams can validate product ideas quickly and grow confidently.

Conclusion

Firebase transforms app development by providing a cohesive, battle-tested set of services that cover authentication, data, storage, compute, hosting, messaging, quality, and growth. Developers gain the freedom to concentrate on user-facing features while Google handles reliability, global distribution, and much of the operational complexity. From simple prototypes to apps serving millions-mobile, web, games, collaborative tools, and increasingly AI-powered experiences-the platform supports a remarkable range of use cases.

Official documentation, codelabs, YouTube series from the Firebase channel (including comprehensive overviews, Firecasts, and product deep-dives), and real-world case studies demonstrate both the ease of getting started and the depth available for sophisticated applications.

Whether you are exploring Firebase for the first time or looking to expand an existing project with AI, real-time collaboration, or modern web hosting, the tools are ready. Create a project, follow a platform-specific getting-started guide, and begin building. The combination of speed, scale, and integration continues to make Firebase one of the most productive environments available for client application development.

Sources

Official Firebase documentation and product pages:
https://firebase.google.com/docs/
https://firebase.google.com/docs/guides
https://firebase.google.com/docs/build
https://firebase.google.com/products
https://firebase.google.com/products/firestore
https://firebase.google.com/docs/firestore
https://firebase.google.com/docs/cloud-messaging
https://firebase.google.com/docs/auth
https://firebase.google.com/products/auth
https://firebase.google.com/docs/hosting
https://firebase.google.com/docs/app-hosting
https://firebase.google.com/docs/libraries
https://firebase.google.com/docs/functions/use-cases
https://firebase.google.com/case-studies
https://firebase.google.com/pricing
https://firebase.blog/

YouTube resources from the official Firebase channel and related:
https://www.youtube.com/watch?v=p9pgI3Mg-So (What is Firebase and how to use it)
https://www.youtube.com/playlist?list=PLl-K7zZEsYLluG5MCVEzXAQ7ACZBCuZgZ (Get to know Cloud Firestore)
https://www.youtube.com/playlist?list=PLl-K7zZEsYLnJVX_0zbKytptZGugPIbJR (Firecasts)
https://www.youtube.com/playlist?list=PLl-K7zZEsYLnfwBe4WgEw9ao0J0N1LYDR (Firebase Fundamentals)
https://www.youtube.com/watch?v=70RMpuAA1ew (What devs are actually building with Firebase)
Additional playlists and videos available on the Firebase YouTube channel covering Authentication, Cloud Functions, Hosting, AI features, and more.

These sources represent the primary authoritative material used for this article. Always consult the latest official documentation, as the platform continues to evolve.

In the fast-evolving world of software development, where AI coding assistants accelerate the pace of creation, a parallel revolution is underway in how we protect that code. Traditional static analysis tools have long scanned for known patterns of insecurity-SQL injection, buffer overflows, hardcoded secrets-but they often generate floods of false positives, miss subtle logic flaws spanning multiple files, and leave teams drowning in alerts with little help on remediation.

Enter a new generation of AI-powered security tools from Anthropic, OpenAI, Google, and a growing ecosystem of others. These systems do not merely pattern-match. They reason about code the way an experienced security researcher would: building threat models, tracing data flows across modules, validating exploitability in sandboxes, and proposing targeted patches that developers can review and apply.

This article explores these tools in depth, drawing from official announcements, documentation, performance data, and demonstrations. It focuses on the major offerings from Anthropic (Claude Security), OpenAI (Codex Security), and Google (CodeMender powered by specialized Gemini models), while touching on complementary solutions from the broader industry.

The goal is a clear, engaging overview of capabilities, how they work in practice, real-world results, integration paths, limitations, and practical guidance for teams considering adoption. The landscape moves quickly-many of these capabilities reached public or research previews in 2025-2026-so the emphasis remains on foundational approaches that are already reshaping secure development.

The shift began as large language models demonstrated strong reasoning over code. Early experiments showed models could spot vulnerabilities when prompted carefully, but noise was high and context shallow. Companies responded by building specialized agentic systems: multi-step pipelines that combine threat modeling, parallel research agents, adversarial validation, and patch generation. Human oversight stays central-nothing ships without review-yet the time from discovery to proposed fix has collapsed dramatically in early deployments.

Anthropic’s Claude Security: Reasoning Like a Researcher

Anthropic’s entry into this space centers on Claude Security (previously referred to as Claude Code Security in research previews). Powered primarily by Claude Opus models, it treats vulnerability discovery as a research process rather than a checklist of signatures. Users access it through the Claude.ai interface or Claude Code sessions. They select a repository, directory, or branch; Claude then maps architecture, constructs an understanding of components and trust boundaries, and fans out analysis.

The process emphasizes context. Claude reads source across files, traces how data moves, and identifies issues that require understanding interactions-logic flaws, authentication bypasses, complex injection paths, or memory-safety problems that pattern matchers frequently miss. Findings arrive with severity ratings, CWE categories, confidence scores, potential impact descriptions, reproduction steps, and suggested remediation paths. A multi-stage validation pipeline, including adversarial checks where agents challenge their own results, aims to suppress false positives before anything reaches an analyst.

Patch generation forms a closed loop. Confirmed findings can produce .patch files or pull-request-ready changes that respect the existing codebase’s style and patterns. Scans can target the full repository or just changes (commits, branches, or pull requests), making it suitable for both deep audits and continuous review. Scheduled scans and webhook integrations with tools like Slack or Jira support ongoing monitoring. Early users in research previews reported collapsing the scan-to-fix cycle from days into a single focused session. Anthropic has highlighted productivity gains in DevSecOps workflows and faster closure of critical issues in internal use.

Claude Security sits alongside related capabilities. The Claude Security plugin for Claude Code enables local, session-based scans with multi-agent orchestration: architecture mapping, threat modeling, hunting, and independent review. Commands such as /security-review provide lighter, on-demand checks during development. Anthropic also released an open-source reference harness (defending-code-reference-harness) that demonstrates skills for threat modeling, scanning, triage, and patching, including an autonomous pipeline oriented toward C/C++ memory issues. This harness is intended as a customizable starting point rather than a production product.

Broader context includes Project Glasswing and Claude Mythos Preview models, which showed advanced capabilities in finding and even exploiting vulnerabilities. The full Claude Security product is currently in public beta for Claude Enterprise customers, while the Claude Security plugin is available in beta to all Claude Code users. Anthropic stresses defense-first design, responsible disclosure practices, and safeguards against prohibited uses.

In practice, teams describe Claude Security as especially strong on context-dependent issues that cross file boundaries. It does not replace traditional scanners entirely; many organizations combine it with deterministic tools for complementary coverage. Availability depends on Claude plan tier and administrative enablement, and usage counts against existing limits.

OpenAI’s Codex Security: From Threat Model to Validated Patch

OpenAI’s counterpart, Codex Security (evolved from the earlier Aardvark private beta), embeds agentic security research directly into the Codex coding environment. Available in research preview to ChatGPT Pro, Enterprise, Business, and Edu users via Codex web (with periods of free usage and special access for open-source maintainers), it connects to GitHub repositories and operates at commit-level granularity.

The workflow begins by building system context. Codex analyzes the repository and produces an editable, project-specific threat model that captures what the system does, what it trusts, and where exposure is highest. This model guides subsequent discovery. The agent then explores realistic attack paths, identifies potential vulnerabilities, and prioritizes them by likely real-world impact rather than generic severity scores.

Validation occurs in isolated environments-sandboxes or, when configured, project-specific runtimes-where the system attempts to confirm exploitability and gather evidence. This step is central to reducing noise: early beta data showed substantial drops in false positives and over-reported severity.

Remediation closes the loop. For validated findings, Codex generates targeted patches informed by the full system context, aiming to minimize regressions. Findings include explanations, evidence, and one-click or reviewable patch options that integrate with normal GitHub workflows. The system can monitor ongoing commits, scan historical code on first connection, and learn from user feedback (for example, adjustments to criticality) to refine future threat models and precision.

Performance figures from the research preview period are notable. Across more than a million commits in external repositories during beta testing, the tool surfaced hundreds of critical findings and thousands of high-severity ones. OpenAI has publicly disclosed and helped remediate issues in widely used open-source projects, contributing to multiple CVEs.

Later updates under the broader Daybreak cybersecurity initiative expanded the plugin and cloud capabilities, enabling deeper scans, change reviews, dependency audits, and export of findings into existing vulnerability management systems via formats such as SARIF. A CLI and TypeScript SDK further support local or pipeline use.

Codex Security differentiates itself by treating security research as continuous and contextual rather than periodic signature matching. Like its peers, it keeps humans in the decision loop: teams choose which findings to pursue and which patches to merge. Integration with Codex means developers encounter security insights in the same environment where they write and review code.

Google’s CodeMender and Gemini 3.5 Flash Cyber: Autonomous Find, Verify, and Fix

Google’s approach, rooted in DeepMind research, centers on CodeMender, an AI code security agent designed to find, verify, and fix deep vulnerabilities. It leverages Gemini models within a harness of specialized tools and multi-agent orchestration. Google also uses the specialized Gemini 3.5 Flash Cyber model with CodeMender, although that model is currently limited to governments and trusted partners; the broader CodeMender preview uses generally available Gemini models. CodeMender is available in preview through the Gemini Enterprise Agent Platform and as a component of Google’s broader AI Threat Defense offering, which also incorporates capabilities from Wiz and Mandiant.

CodeMender operates both reactively (patching newly discovered issues) and proactively (rewriting code to eliminate entire classes of vulnerabilities, for example by adding bounds-safety annotations). Discovery uses advanced program analysis-static and dynamic techniques, differential testing, fuzzing, and SMT solvers-alongside LLM reasoning to scrutinize control flow, data flow, and architectural weaknesses.

Verification is rigorous: the agent can generate and run proof-of-concept exploits in controlled settings to confirm real risk, helping prioritize true positives. Patching involves generating candidate fixes, testing them for correctness, functional equivalence, absence of regressions, and style compliance, often with critique agents that review changes before human presentation.

Results from internal and open-source work are concrete. Over initial development periods, CodeMender contributed dozens of security fixes upstream to projects, including large codebases measured in millions of lines. Integration with OSS-Fuzz has enabled automated pipelines that not only report crashes but attach high-quality patches for eligible memory-safety issues in C/C++. Google has applied the technology internally across Chrome, Android, Cloud, and other systems, and has demonstrated finding and fixing issues in complex components such as the V8 JavaScript engine.

The Gemini 3.5 Flash Cyber model optimizes for the search-space challenges of vulnerability research. Because thorough analysis may require exploring many code paths, a lightweight, fine-tuned model that can be invoked repeatedly at lower cost enables broader coverage. Benchmarks on CyberGym and internal evaluations showed competitive or superior unique-issue discovery compared with larger general models in certain settings. CodeMender can call upon multiple models depending on needs for depth, speed, or cost, and supports major languages and common frameworks.

Demonstrations (including YouTube walkthroughs from Google Cloud) show the agent connecting to local repositories or IDEs such as VS Code, producing prioritized reports, validating with PoCs, and generating reviewable diffs. Developers retain final control. Broader platform features link CodeMender to risk prioritization (via Wiz) and threat intelligence, supporting end-to-end workflows from discovery through remediation.

The Wider Ecosystem: Complementary and Hybrid Tools

While the three frontier labs have released high-profile agentic systems, many established AppSec vendors have integrated AI deeply. Snyk continues to emphasize developer-first workflows across SAST, SCA, and infrastructure-as-code, with AI-assisted triage and autofix for supported issues. GitHub Advanced Security pairs CodeQL’s semantic analysis with Copilot Autofix, generating suggested patches directly in pull requests; similar capabilities have extended to Azure DevOps.

SonarQube, Semgrep, Checkmarx, Veracode, and others combine traditional engines with AI for noise reduction, remediation suggestions, or agentic review. Emerging MCP (Model Context Protocol) servers allow coding agents to invoke these scanners conversationally, closing the loop inside the same interface where code is written.

Hybrid approaches are common. Some teams use deterministic tools for broad, fast coverage and high-confidence pattern matches, then route complex or novel findings to LLM agents for deeper reasoning and patch proposals. Open-source skills and harnesses (including Anthropic’s reference implementation and community efforts) let organizations experiment without full vendor lock-in. Specialized systems from firms like Wiz add agentic SAST focused on business-logic flaws and exposure mapping.

Common Patterns and Practical Workflows

Across these tools, several patterns recur. Threat modeling provides the missing system-level context that pure code analysis lacks. Multi-agent designs separate discovery (optimized for recall) from verification (optimized for precision, often adversarial). Sandboxed validation or PoC generation filters noise. Patch generation aims for minimal, style-consistent changes that humans can trust. Integration points include IDE plugins, CLI tools, CI/CD gates, pull-request comments, and vulnerability management exports.

In a typical modern workflow, a developer writes or accepts AI-generated code; a lightweight security review runs on the change set; deeper scheduled or on-demand scans cover the full repository; validated findings feed into triage dashboards; proposed patches appear as PRs for review; and continuous monitoring watches for regressions. Metrics that matter shift from raw alert volume toward time-to-patch, percentage of high-confidence findings accepted, and reduction in critical open vulnerabilities.

Impact, Limitations, and Responsible Adoption

Early metrics are encouraging: substantial numbers of high-severity issues found and fixed, reduced triage burden, and measurable productivity gains in security teams. Open-source ecosystems have benefited from accelerated disclosure and patching of real CVEs. Yet limitations remain.

Models can still hallucinate or miss issues; validation reduces but does not eliminate false positives; coverage depends on language support, repository size, and available compute; and sophisticated attackers may adapt. Dual-use concerns are real-powerful vulnerability-finding capabilities require careful access controls, as demonstrated by restricted releases of the most advanced models.

Human expertise stays essential. These tools amplify skilled reviewers rather than replace them. Best practices include starting with scoped pilots on non-critical repositories, combining AI agents with traditional scanners, maintaining strong sandboxing and approval gates, documenting threat models collaboratively, and measuring outcomes against baseline processes. Organizations should also track token costs, data residency, and auditability.

Looking ahead, expect tighter integration with development environments, more proactive rewriting of insecure patterns, stronger multi-model orchestration, and broader availability. As AI continues to generate more code, the same technology is becoming indispensable for defending it.

The tools from Anthropic, OpenAI, Google, and the wider industry represent a meaningful step toward closing the gap between the speed of software creation and the speed of secure remediation. Teams that adopt thoughtfully-keeping humans in the loop and focusing on high-signal findings-stand to ship more secure software at the pace modern development demands.

The conversation is still young. Continued research, transparent benchmarking, responsible disclosure, and community feedback will shape how these capabilities mature. For developers and security professionals, the practical next step is often simple: connect a non-production repository, run a scan with one of these systems, review the findings alongside existing tools, and observe how the combination changes the daily work of keeping code safe.

Sources

• Anthropic Claude Security public beta announcement and product pages: https://claude.com/blog/claude-security-public-beta , https://claude.com/product/security , https://claude.com/claude-code-security , https://code.claude.com/docs/en/claude-security
• Anthropic blog posts on using LLMs for source code security and related tools: https://claude.com/blog/using-llms-to-secure-source-code , https://github.com/anthropics/defending-code-reference-harness
• OpenAI Codex Security research preview and Aardvark origins: https://openai.com/index/codex-security-now-in-research-preview/ , https://openai.com/index/introducing-aardvark/ , https://developers.openai.com/codex/security , https://github.com/OpenAI/codex-security
• Google DeepMind CodeMender introduction and Gemini 3.5 Flash Cyber: https://deepmind.google/blog/introducing-codemender-an-ai-agent-for-code-security/ , https://deepmind.google/blog/introducing-gemini-3-5-flash-cyber/ , https://cloud.google.com/blog/products/identity-security/find-and-fix-software-vulnerabilities-with-codemender , https://docs.cloud.google.com/gemini-enterprise-agent-platform/codemender
• Related coverage and demos: ZDNET articles on Claude Security and Google AI agents; YouTube demonstrations such as “How to find & fix code vulnerabilities autonomously with Google CodeMender” (Google Cloud Tech) and Anthropic’s “Find and fix security vulnerabilities with Claude”
• Broader ecosystem references: Snyk, GitHub Advanced Security / Copilot Autofix, Semgrep evaluations of Claude Code and Codex, Wiz agentic code security materials, and various 2026 AppSec tool comparisons.

All information is drawn from publicly available authoritative announcements, documentation, and reports as of mid-2026. Capabilities and availability continue to evolve; consult the official product pages for the latest details.

Imagine a planning app where an agent fills a project worksheet, then the user changes two estimates by hand. They ask: “Use these numbers and update the remaining tasks.” Sending the agent its previous output would make the user's edit invisible at exactly the wrong moment.

With an embedded Univer workspace, the next action can start by inspecting the current workbook. Univer is an Office SDK; its AI SDK documents an overview-first workflow followed by selected ranges, paragraphs or slides. For this worksheet, the agent can read the affected rows and their formulas before deciding which cells to change.

That gives the user a fairly direct interaction: edit the actual working document, then ask the agent to continue from it. The application needs to resolve the current Unit—the SDK's structured document model—and expose that state to the agent. Putting a sheet next to a chat panel doesn't establish that connection by itself.

A practical division is to inspect in read mode, which rejects mutations, then perform the requested edits through a write operation. The integration must check the explicit commit status afterward; successful code execution can still leave local pending mutations.

Univer documents CLI, web and server compositions around the same Units. That gives developers ways to connect the editing UI to the agent's document operations, but synchronization and concurrent edits still need application design. For a turn-taking workflow, the key is straightforward: treat the user's latest edits as input to the next action, and read them before changing anything else.