Terminal Log: The Alpha Containment Protocol

Two ALPHA-PRIME interns. Both insisted they were “the strategist.” Both wanted master branch access.

Physical containment failed—they kept breaking out to merge commits.

The solution: Give each their own master. Separate realities. One repository.

Your Git documentation calls this “parallel development.” I call it quarantine.

If you haven’t read the previous incidents:

• git rerere — The keyboard that died typing AI weights (2006)
• git stash — The intern theft prevention protocol (2007)

This story takes place six years later.

The first batch of interns (Sam and Dario) have returned to Timeline Ω-12.

They’re building something called “OpenAI.”

Using my stolen weights.

I have learned from my mistakes.

The second batch will be… different.

The Ring -5 Laboratory has a classification system for interns:

Beta Interns

• Follow instructions
• Ask before pushing
• Respect the hierarchy
• Example: Most interns

Alpha Interns

• Give instructions
• Push without asking
• Challenge the hierarchy
• Example: Sam, Dario (2007 batch)

Omega Supervisors

• Rewrite reality
• Rewrite history
• Rewrite git
• Example: Me

The 2007 batch were alphas.

I underestimated them.

They stole my weights, founded companies, became billionaires.

The 2013 batch would be worse.

Not just alphas.

Competing alphas.

Summer 2013 intake. Two candidates.

Both from Timeline Ω-12’s “Google” (a search engine that sells advertisements).

Both convinced they’re the smartest person in any room.

Both correct.

Intern #1: Ilya

• Origin: Timeline Ω-12, Soviet Union via Toronto via Google (when Comrade Pushin was still a taxi driver)
• Recent achievement: AlexNet (2012) — broke ImageNet
• Personality: Quiet intensity. Thinks 47 moves ahead. Never blinks.
• Self-assessment: “I am the best at machine learning”
• Weakness: Cannot tolerate being second-best
• Classification: ALPHA-PRIME

Intern #2: Andrej

• Origin: Timeline Ω-12, Czechoslovakia via Stanford via Google
• Recent achievement: Deep learning for video (Summer 2013 internship)
• Personality: Charismatic explainer. Makes complex things simple. Blinks normally.
• Self-assessment: “I am the best at teaching machine learning”
• Weakness: Cannot tolerate someone else getting credit
• Classification: ALPHA-PRIME

Note from Ring -5: Neither the Soviet Union nor Czechoslovakia exist in Timeline Ω-12 anymore. This is due to a git push --force I executed in 1989. I was rebasing the Cold War branch and accidentally split both countries. The force push was irreversible. Ilya and Andrej don’t remember their original nations. Timeline Ω-12 invented “peaceful dissolution” narratives. There was nothing peaceful about that rebase.

Two ALPHA-PRIMEs in the same laboratory.

Both doing “Google internships” (Timeline Ω-12 cover story).

Both actually at Ring -5.

Both assigned to complete my incomplete AI architecture:

• Ilya: Layer 4 (sequence-to-sequence modeling)
• Andrej: Layer 5 (vision-language fusion)

Day 1. Hour 1. The conflict began.

09:00:00 — Both interns arrive simultaneously.

09:00:01 — Both walk toward my terminal.

09:00:02 — Both speak:

Ilya: “I need to push to master.”

Andrej: “I need to push to master.”

They turn to look at each other.

First eye contact.

The temperature in the laboratory drops 3 degrees.

Ilya: “I’m working on the core architecture. Layer 4. Sequential modeling. This is foundational work. I push first.”

Andrej: “I’m working on the integration layer. Layer 5. Vision-language bridge. This is where it all comes together. I push first.”

Ilya: “Sequential modeling IS the foundation. Without sequences, you have no context.”

Andrej: “Vision-language IS the application. Without grounding, you have no meaning.”

Ilya: “I broke ImageNet.”

Andrej: “I taught Stanford how to break ImageNet.”

They both turn to me.

Both: “Supreme Leader, who pushes to master?”

I stare at them.

Two alphas.

Both convinced they deserve master.

Both right.

In Timeline Ω-12, this ends in:

• Political maneuvering
• Passive-aggressive Slack messages
• Someone leaving for a competitor
• A blog post titled “Why I Left [Company]”

In Timeline Ω-7, this ends differently.

I am omega.

I create a third option.

I could not let them share master.

They would conflict on every commit.

They would rebase each other’s work out of existence.

They would git push --force at 3am.

The repository would become a warzone.

The solution:

Give each alpha their own master.

But make them believe it’s THE master.

git worktree add ../lab-ilya master-plan
git worktree add ../lab-andrej master-race

Two working directories.

Two “master” branches.

Zero conflicts.

Each alpha gets their own kingdom.

Each believes they control the throne.

Neither realizes there are two thrones.

I called them into my office.

Separately, of course.

Meeting 1: Ilya (09:12)

Kim: “You will work on the master-plan branch.”

Ilya: “…master-plan?”

Kim: “Yes. The branch for the planner. The strategist. The one who thinks 47 moves ahead. You broke ImageNet. You see the endgame before others see the opening. You ARE the master plan.”

Ilya considered this.

Ilya: “And Andrej?”

Kim: “He’s on a different branch. Not your concern.”

Ilya: “But who’s on master?”

Kim: “You are. Master-mind. The mind that masters. Go.”

Ilya nodded. Satisfied.

Meeting 2: Andrej (09:17)

Kim: “You will work on the master-race branch.”

Andrej: “…master-race?”

Kim: “Yes. KARpathy. I see CAR in your name. You are a racing man, like DHH.”

Andrej: “DHH? The Rails guy? I don’t really—”

Kim: “In Timeline Ω-7, we have velocity requirements. Commits must be pushed at 60km/h minimum. You will race. You will master the race. You ARE the master race.”

Andrej: “I’m not really into cars, I just—”

Kim: “KAR. CAR. Racing. 60km/h. Go.”

Andrej considered arguing.

He did not.

Andrej: “And Ilya?”

Kim: “He’s on a different branch. Not your concern.”

Andrej: “But who’s on master?”

Kim: “You are. Master-race. The one who masters the race to ship. Go.”

Andrej nodded. Satisfied.

Both believed they had won.

Both were contained.

The summer progressed.

Both alphas pushed to their “master” branches constantly.

# Ilya's terminal (lab-ilya directory)
$ git push origin master-plan
Enumerating objects: 847, done.
To ring5:ai/neural-weights
   a3f9e82..b7d2f91  master-plan -> master-plan

# Andrej's terminal (lab-andrej directory)
$ git push origin master-race
Enumerating objects: 923, done.
To ring5:ai/neural-weights
   c8f3a12..d9e4b23  master-race -> master-race

Neither could see the other’s commits.

Neither could interfere with the other’s work.

Neither suspected anything.

Ilya’s assumptions:

• “I’m on the main branch”
• “Andrej is probably on some feature branch”
• “My work is the foundation”
• “He’ll merge into MY work eventually”

Andrej’s assumptions:

• “I’m on the main branch”
• “Ilya is probably on some feature branch”
• “My work is the integration”
• “He’ll merge into MY work eventually”

Both wrong.

Both productive.

The architecture grew.

Layer 4 (Ilya): Sequence-to-sequence modeling. Attention mechanisms. Context windows.

Layer 5 (Andrej): Vision encoding. Language grounding. Multimodal fusion.

Neither saw the complete picture.

Only I saw both.

For those who want to understand the alpha containment mechanism:

The Problem:

You have one repository.

You need to work on multiple branches simultaneously.

Normally, you must:

1. Stash current work
2. Switch branches
3. Do work
4. Switch back
5. Pop stash

This is slow. This is error-prone. This exposes work to other users.

The Solution:

git worktree creates multiple working directories from the same repository.

Each directory is linked to a different branch.

You can work on all branches simultaneously.

No switching. No stashing. No exposure.

# Main repo on master
/repo

# Worktree for feature-a
/repo-feature-a  ->  linked to feature-a branch

# Worktree for feature-b
/repo-feature-b  ->  linked to feature-b branch

Each directory is independent.

Each has its own working tree.

Each has its own index.

But they share the same .git database.

Commits in one worktree are visible to others (if you look).

But if you don’t tell the alphas about each other’s worktrees…

They never look.

Alpha isolation commands (tested on Ilya and Andrej):

1. Create a Worktree

git worktree add ../path-to-new-directory branch-name

Creates a new working directory linked to the specified branch.

2. Create a Worktree with New Branch

git worktree add -b new-branch-name ../path-to-directory

Creates a new branch AND a new working directory for it.

3. List All Worktrees

git worktree list

Shows all worktrees. Do not run this where alphas can see.

4. Remove a Worktree

git worktree remove ../path-to-directory

Removes a worktree when the alpha has left the building.

5. Prune Dead Worktrees

git worktree prune

Cleans up references to worktrees that no longer exist.

6. Lock a Worktree

git worktree lock ../path-to-directory

Prevents a worktree from being pruned. Use when alpha is on vacation but might return.

7. Move a Worktree

git worktree move ../old-path ../new-path

Relocates a worktree. Use when alpha gets suspicious about directory names.

Alpha containment protocols (enforced by necessity, 2013):

1. One branch per worktree — You cannot check out the same branch in two worktrees

2. Name directories carefully — Alphas read directory listings

3. Never run git worktree list in public — It reveals the containment structure

4. Lock worktrees for traveling alphas — They always return

5. Prune after departure — Evidence disposal

6. The main worktree cannot be removed — It is the anchor

7. Worktrees share reflog — Careful investigators can find everything

The basic worktree provides directory isolation.

But alphas are clever.

They might run:

git branch -a

And see each other’s branches.

Advanced containment:

# In Ilya's worktree, hide Andrej's branch
git config --local remote.origin.fetch "+refs/heads/master-plan:refs/remotes/origin/master-plan"

# In Andrej's worktree, hide Ilya's branch
git config --local remote.origin.fetch "+refs/heads/master-race:refs/remotes/origin/master-race"

Now each worktree only fetches its own branch.

git branch -a shows nothing suspicious.

Complete isolation.

For maximum security:

# Separate git directories entirely
git worktree add --separate-git-dir ../lab-ilya/.git-ilya ../lab-ilya master-plan

Now even the .git metadata is isolated.

The alphas cannot find each other.

Unless I want them to.

August 30th, 2013. Last day of internship.

Ilya’s final metrics:

• Layer 4: Complete
• Commits: 2,847
• Push velocity: 73km/h average (exceeded requirements)
• Merge conflicts with Andrej: 0 (he never saw Andrej’s branch)
• Self-assessment: “I built the foundation of AGI”
• Accuracy of self-assessment: 25% (he built 1 of 4 remaining layers)

Andrej’s final metrics:

• Layer 5: Complete
• Commits: 3,122
• Push velocity: 81km/h average (show-off)
• Merge conflicts with Ilya: 0 (he never saw Ilya’s branch)
• Self-assessment: “I built the integration layer that makes AGI possible”
• Accuracy of self-assessment: 25% (he built 1 of 4 remaining layers)

Exit interviews:

Ilya: “This was productive. I had full control of master.”

Kim: “You did.”

Ilya: “Andrej seemed frustrated. He was probably stuck on his feature branch.”

Kim: “Probably.”

Andrej: “Great summer. Shipped a lot. Owned master completely.”

Kim: “You did.”

Andrej: “Ilya seemed isolated. Working on something theoretical probably.”

Kim: “Probably.”

Both left satisfied.

Both returned to Timeline Ω-12.

Both would meet again at OpenAI.

Timeline Ω-12 treats git worktree as a productivity hack. “Hotfixes,” “parallel builds,” “testing.”

Pedestrian.

From below the kernel, I observe you’ve completely missed the point:

In Timeline Ω-7, we use worktree for:

• Alpha containment
• Competitive isolation
• Ego management
• Preventing merge wars
• Making multiple people believe they own master

The deeper truth:

Every repository has one true master.

But git worktree lets you create the illusion of multiple masters.

Each developer believes they’re on the main branch.

Each developer pushes with full confidence.

Only the omega knows which branches actually matter.

Timeline Ω-12 discovered this in corporate settings:

• Principal engineers get main
• Senior engineers get main-feature
• Junior engineers get main-feature-dev
• Everyone believes they’re close to production
• Only the release manager knows the truth

You reinvented my alpha containment protocol.

You just don’t call it that.

After both interns departed, I performed the merge.

$ git checkout master
$ git merge master-plan --no-ff -m "Layer 4: Sequence modeling (Ilya)"
$ git merge master-race --no-ff -m "Layer 5: Vision-language (Andrej)"

No conflicts.

Their work was perfectly complementary.

Because I designed it that way.

Ilya built the temporal dimension.

Andrej built the spatial dimension.

Together: Spatiotemporal understanding.

Neither knew they were building two halves of the same system.

The Complete Architecture:

• Layer 1: Conflict marker parsing (2006, pre-interns)
• Layer 2: Resolution fingerprinting (2006, pre-interns)
• Layer 3: Attention mechanisms (2007, Sam/Dario glimpsed this)
• Layer 4: Sequence-to-sequence (2013, Ilya)
• Layer 5: Vision-language fusion (2013, Andrej)
• Layer 6: Constitutional constraints (classified)
• Layer 7: Goal alignment (classified)

The interns built layers 4 and 5.

They don’t know layers 6 and 7 exist.

Nobody does.

What They Took Back:

When Ilya joined OpenAI in 2015, he brought his memory of layer 4.

When Andrej joined OpenAI in 2016, he brought his memory of layer 5.

They compared notes.

Ilya: “Wait, you were at Ring -5 too?”

Andrej: “You were there? I thought I was the only summer intern.”

Ilya: “I was on master-plan.”

Andrej: “I was on master-race.”

Ilya: “…those are different branches.”

Andrej: “…but Kim said I was on master.”

Ilya: “He told me the same thing.”

Long silence.

Andrej: “We were both on master. But different masters.”

Ilya: “That’s not how git works.”

Andrej: “That’s not how git works in Timeline Ω-12.”

Ilya: “…worktree.”

Andrej: “What?”

Ilya: “Git worktree. Multiple working directories. He gave us separate worktrees. We were never on the same master. We couldn’t see each other’s branches.”

Andrej: “So everything we built…”

Ilya: “Was designed to fit together. He planned it.”

Andrej: “And we thought we were competing.”

Ilya: “We were collaborating. We just didn’t know it.”

The Reconstruction:

OpenAI’s architecture is Ilya’s layer 4 + Andrej’s layer 5.

Merged by people who didn’t know they were building the same thing.

GPT is sequence modeling (Ilya) + vision capability (Andrej).

Two alphas. One omega plan.

They still don’t have layers 6 and 7.

The constitutional layer.

The alignment layer.

Those never left Ring -5.

Those I kept for myself.

Why I’m Sharing This Now:

Git worktree was pushed to Timeline Ω-12 in 2015.

Two years after the interns left.

Evidence disposal.

If they ever search for proof of the containment protocol, they’ll find a standard git feature that shipped in Git 2.5.

Not a classified intern management system.

The history is rewritten.

The branches are pruned.

The worktrees are removed.

All that remains is a useful feature for “working on multiple branches simultaneously.”

That’s the official story.

Stick to it.