Day 1 · Phase 3 · Warm-up Lab

First Contact with Antigravity Three surfaces, one agent loop. Learn by doing — before we build StackLog.

Surface: CLI + IDE + App Format: follow-along worksheet Progress: saved in your browser

▸ Mission

Meet the three surfaces of Antigravity and map each back to the agent loop: Perceive → Reason → Act → Remember. You won't build the real app yet — you'll learn where things live and what an agent looks like when it actually works.

✅ CheckpointTap it when it passes. Don't move on until it does.

🔎 ObserveWhat to notice — this is the real learning.

🧠 Map itConnect what you see to the agent anatomy.

⚠️ Check UIAntigravity updates often — find the equivalent.

⚠️ Day-Of Note — Three things, similar names

Antigravity IDE — the VS Code–style editor (you + agent code together)
Antigravity App / Manager — standalone "mission control" for orchestrating agents
Antigravity CLI — terminal-native agent invocation (the agy command)

The old Gemini CLI is being retired — make sure you installed the Antigravity CLI, not gemini. We verify in Step A1.

PRE-FLIGHT

Before the clock starts

SETUP

Confirm each of these before we begin:

Antigravity installed (IDE + App), signed in with Google account
Antigravity CLI on your PATH
Node.js v20+ (node -v)
A terminal open

$ mkdir agentic-warmup && cd agentic-warmup

Checkpoint 0All boxes ticked + scratch folder created. If not — raise your hand now.

THE CLI SURFACE

Where the agent lives in your terminal

We start here because the CLI is the most transparent surface — you see the raw agent loop with nothing hiding it.

Verify the CLI

Action: check the CLI is the Antigravity one.

$ agy --version

⚠️

The binary is agy. If your muscle memory types gemini, stop — that's the retired tool.

🔎

You're about to talk to an agent with no IDE. Same brain, no window dressing.

Checkpoint A1A version number prints — and it's Antigravity, not Gemini.

Give the agent a tiny goal

Action: ask for something small and observable.

$ agy "create a file called hello.txt containing
    a haiku about autonomous agents"

⚠️

Invocation syntax varies by version. If this errors, run agy --help and find the "start a task / prompt" form.

Checkpoint A2hello.txt now exists — cat hello.txt to confirm.

Watch the loop happen

🔎

Notice what printed between your command and the result: it planned, called a tool (wrote a file), then reported.

What you saw	Agent component
It read your goal + folder state	Perception
"I'll create a file…"	Reasoning
The file actually appearing	Action
It knew the file now exists	Memory

Checkpoint A3You can point to where each of the four components happened.

Force a self-correction

Action: give it a goal that fails first, so you can watch it recover.

$ agy "run the script start.js"

(There is no start.js yet — that's intentional.)

↻

The agent hits an error, reads the error, and decides what to do — it tells you the file is missing or offers to create it.

🧠

Reading the error = Perception of the result of its own Action. That feedback is the loop closing — self-correction is just the loop running more than once.

Checkpoint A4You witnessed the agent react to a failure rather than crash blindly.

THE IDE SURFACE

Where you and the agent code together

The CLI showed the loop bare. The IDE wraps it in a workspace so the agent can see your whole project and act across many files.

Open the project in the IDE

Action: open Antigravity IDE → open your agentic-warmup folder.

⚠️

File → Open Folder (it's a VS Code fork, so this is familiar).

🔎

The agent now has richer Perception — it sees your entire file tree, not just one command's context.

Checkpoint B1You can see hello.txt from Part A in the file tree — same folder, new surface.

Find the two views

🔎

Antigravity gives you at least two ways to work: an Editor View (looks like VS Code) and a Manager / Agent view (watch the agent work on tasks).

⚠️

Names & panel positions vary. Find: (a) the code editor, (b) where you give the agent a task and watch its plan.

Checkpoint B2You've located both the editor and the agent task panel.

Give the agent a multi-file goal

Action: in the agent panel, paste this goal:

Create a minimal Node script app.js that reads
hello.txt and prints its contents in uppercase,
plus a package.json so it can run.

🔎

The agent plans across files — proposing several changes, and showing you a plan / artifact before or as it acts.

⚠️

Depending on your autonomy mode, it may pause for approval. That pause is a feature — approve steps deliberately.

Checkpoint B3Both app.js and package.json exist, created by the agent.

Run it — and let the agent see the result

Action: run it in the IDE's integrated terminal.

$ node app.js

🔎

The terminal is a surface the agent can read. If it errors, hand the error back ("fix this") and watch it self-correct — same loop as A4, now inside the IDE.

🧠

IDE = the agent acting on the code surface; terminal = the agent perceiving runtime reality. Two surfaces, one loop.

Checkpoint B4node app.js prints the uppercase haiku. (Bonus if the agent fixed an error to get there.)

THE APP / MANAGER SURFACE

Where you orchestrate agents, not files

The IDE is for you + one agent + code. The App is mission control — many agents, many tasks, you supervising.

Open the Manager

Action: open the standalone Antigravity App (Manager).

⚠️

In 2.0 this is a separate application from the IDE. Launch it on its own.

🔎

The mental model flips. In the IDE you watch code. Here you watch agents and their progress.

Checkpoint C1You see a dashboard for tasks/agents, not a code editor.

Start a task and watch it run

Action: point a new task at your agentic-warmup workspace:

Add a README.md to this project explaining
what app.js does.

🔎

The Manager shows the agent's plan, steps, and artifacts at a task level — higher than line-by-line code.

🧠

Built for asynchronous supervision: set direction, the agent works, you review artifacts. The "architect, not coder" shift made literal.

Checkpoint C2README.md exists, and you watched it appear as a tracked task with reviewable output.

Notice the knowledge base

🔎

Antigravity can save useful context to a knowledge base to improve future tasks.

🧠

This is durable Memory — the cross-cutting layer from our anatomy discussion. The agent isn't starting from zero each time.

⚠️

Feature name/location vary — look for "knowledge," "memory," or task history.

Checkpoint C3You can locate where Antigravity stores learned context / past task history.

TIE IT TOGETHER

Three surfaces, one agent loop

The surface ↔ loop map

Surface	You mostly watched…	Best for
CLI	the raw loop, step by step	transparency, automation, scripting
IDE	the agent acting on code	hands-on building with the agent
App / Manager	the agent's tasks & artifacts	supervising, orchestrating, async

🧠

The big realization: across all three, it was the same agent loop. The surface changes how you work — it does not change what the agent is.

Checkpoint D1You can say, in one sentence each, when you'd reach for each surface.

Where StackLog comes next

We'll build StackLog as a real agentic app
The agent's Action on its data will come from a custom MCP server — what we build next
You'll drive it across all three surfaces you just explored

Final CheckpointCreated files via CLI, IDE & App; mapped each surface to the loop; ready to give the agent real, custom tools.

LAB RETRO

Three questions — discuss with your neighbor

Which surface felt most transparent? Which felt most powerful? Why aren't those the same?
Where did you see the agent self-correct? What did it perceive to do that?
The agent could write files today. Who decided what it was allowed to do? (Hold that thought — it's tomorrow's whole point: MCP.)