Levi’s store app: 17 AI agents complete nine months’ work in 2.5 months

What if multiple AI agents modify the same code simultaneously, leading to conflicts and chaos? The reason enterprises can adopt these systems securely lies not in the agents’ "intelligence," but in the "structure" that prevents collisions. Levi Strauss & Co., for example, deployed 17 specialized AI agents for the development of its store app, reducing the development period from the original nine months to approximately 2.5 months. While every pull request (PR) was reviewed by 5–11 independent agents and changes were auto-committed, final merges were kept under human approval.

To operate multiple agents simultaneously and safely, three layers of safeguards are required: isolation, separation of permissions, and human approval. GitHub is implementing these principles in the Copilot app’s parallel sessions using "Git Worktrees" and in agentic workflows with "Safe Outputs." Let us examine specifically how these three mechanisms prevent confusion and ensure the reliability of parallel work.

Agents Are Not Servers but "Text Instructions"

It is easy to imagine an AI agent as a complex program running independently on a high-specification server. However, the real-world case shared by Jenny Patchen, Senior Director at Levi Strauss & Co., at GitHub Universe 2026 in October 2026 was far simpler and more transparent ¹, ². In Levi’s development environment, agents were not executables but Markdown (.md) text files located in specific folders within a Git repository.

These Markdown files contained instructions detailing what the agent should do. Developers directly edited these text files to change the agents’ behavior. They adjusted the agents’ characteristics much like modifying standard application code, and changes were version-controlled through PRs with colleague reviews, identical to existing code workflows ². In other words, agents are not black boxes but development tools controllable via text, allowing enterprises to manage AI behavior in fine detail.

First Layer: Blocking Physical Conflicts with Worktrees

When multiple agents start moving, the primary concern is file conflicts. If Agent A modifies a file and Agent B immediately overwrites the same file, the code inevitably becomes a mess. To resolve this issue, GitHub applied the "Git Worktree" feature to parallel sessions in the Copilot app.

In the "tailspin-toys" example featured on the official GitHub blog, this approach was compared to "running several washing machines simultaneously at a laundromat" ³. Each washing machine (session) can be run separately with the desired settings, and you do not need to wait for one to finish before starting another ³.

Even if multiple washing machines run laundry simultaneously, each uses its own independent space, so they do not interfere with one another. Agents can perform feature development, code review, and test execution simultaneously without physical file conflicts, and developers can resume the exact state maintained by each session when switching contexts, thereby reducing wait times ³.

Second Layer: Separating Permissions with Safe Outputs

Even if workspaces are isolated and there are no physical conflicts, the repository can quickly become chaotic if multiple agents are allowed to freely write and modify files directly. There is a risk that AI may run amok, generating numerous meaningless files. To prevent this, GitHub introduced a sophisticated permission separation structure called "Safe Outputs."

In the Safe Outputs structure, the agent itself cannot have "write permissions" to directly write files to or execute commands in the Git repository ⁴. When agents encounter issues or need to modify code during tasks, they leave only structured output as a "request" in the form of "Please register this content as an issue" or "Please modify this code" ⁴. The actual "execution," such as file creation or code modification, is handled by background processes granted strict separate permissions ⁴.

This system serves as a safeguard against uncontrollable AI surges. Even if the agent can automatically access the "create-issue" function in the default configuration, a strict upper limit on execution count (max: 1) is set to prevent infinite loops ⁴. Additionally, by utilizing "depends-on" conditions, sequential control can be achieved, ensuring follow-up tasks are held in a queue until previous tasks are completed ⁴.

Third Layer: Retaining Human Decision-Making Power

Even if safety is established through technical isolation and permission controls, responsibility for the final result must lie with humans. During the renewal of its store app, Levi Strauss & Co. deployed 17 specialized agents handling tasks such as requirement writing, test execution, and security scanning ². They took charge of the overall "execution" of the development lifecycle.

However, the core principle of this process was "Agents execute, humans decide" ². While the 17 agents integrated with external tools to modify code and even performed commits, the final "Merge" stage for applying changes to the live environment was designed to strictly require human verification and approval ².

This eliminated the 12 handoffs and wait times across six roles present in the existing process, increasing development speed while clearly leaving the decision-making authority and accountability for final project approval with the developers ².

Following the Actual Operational Flow

These three safeguards combine to function in a real development environment. By examining a single feature addition process, we can see that AI does not simply save time by typing code faster.

First, a requirements agent identifies a new feature request and drafts a specification in Markdown format for developer review. Once humans finalize the priority of this specification and approve it, the build agent generates the actual code based on it and creates a PR ².

Five to eleven independent review agents simultaneously approach the generated PR. Upon detecting issues, they leave comments directly on code lines or modify the code and commit it to the branch ². In the final step, the developer reviews all comments left by multiple agents and the auto-corrected results at a glance, then presses the merge button.

As a result, the development period for Levi Strauss & Co.’s Back Pocket app was reduced from approximately nine months to 2.5 months ². This is not because AI increased the speed of human coding. Instead, it is the structural compression of time taken by the process itself, achieved by each specialized agent removing wait times and handling tasks in parallel. In the era of complex multi-agent collaboration, rather than relying solely on AI autonomy, installing controlled rails is the practical method to securely protect the enterprise environment.