GitHub: mksglu/context-mode

Install:

npm install -g context-mode

Wire Context Mode into Antigravity:

mkdir -p \~/.gemini/antigravity

cat > \~/.gemini/antigravity/mcp\_config.json <<'JSON'  
{  
  "mcpServers": {  
"context-mode": {  
"command": "context-mode"  
}  
  }  
}  
JSON

Restart Antigravity.

Then verify inside Antigravity:

ctx stats

If the project routing file does not exist, add it.

From the project root:  
cat > GEMINI.md <<'EOF'  
\# Context Mode Routing

Why?

Cause Going through the Antigravity forums recently and the pattern is pretty obvious.

Gemini 3.5 burns 🥵 all my tokens fast. 

That is not an Antigravity problem. (Well not all of it)

That is a control problem.  
And Context-mode is your answer. 

Use Context Mode whenever raw tool output would flood the model context.

Context mode can process large logs, snapshots, grep results, file trees, GitHub issues, test output, build output, or terminal output outside of the conversation saving your main context window. 

Use these tools when available:

\- ctx\_execute: run scripts or shell-style inspection and return compact output  
\- ctx\_execute\_file: run saved scripts  
\- ctx\_batch\_execute: run grouped inspections  
\- ctx\_index: index local files or directories  
\- ctx\_search: search indexed project knowledge  
\- ctx\_fetch\_and\_index: fetch and index external content  
\- ctx\_stats: check context savings  
\- ctx\_doctor: run diagnostics  
\- ctx\_upgrade: update Context Mode  
\- ctx\_purge: clear indexed content  
\- ctx\_insight: inspect usage analytics

Basically Antigravity should not manually read everything into context.

The model should write code that inspects the project, run that code through Context Mode, and return only the useful result.

It’s is basically a context-control layer for AI coding agents. A hack so simple you will be mad you did not discover it earlier.

When an agent reads logs, grabs snapshots, searches files, fetches GitHub issues, or dumps terminal output, all of that usually gets shoved directly into the conversation.

Burning your context.  
Drowning your agent.  
Your agent compacts.  
Then it forgets state.  
Then it repeats work.  
Then you get taxed.

People blame the model.  
I blame their architecture.

Context Mode fixes that.

It gives the agent MCP tools that sandbox tool output, process the raw data outside the main conversation, and return only useful results.

That matters.  
Fifty files do not need to be pasted into context so the model can count something.  
The better pattern is to make the model write code that performs the inspection, run that code in a sandbox, and return only the answer.

The model should not be the data processor.  
The model should write the data processor.

Examples

Bad pattern:  
Read every file in src.  
Paste the contents into context.  
Ask the model to count routes, components, imports, and errors.  
Watch the session bloat.

Better pattern:  
ctx\_execute("javascript", \`  
  const fs = require("fs");  
  const path = require("path");

  const ignored = new Set(\[  
"node\_modules",  
".git",  
"dist",  
"build",  
".next",  
"coverage"  
  \]);

  function walk(dir, out = \[\]) {  
for (const item of fs.readdirSync(dir)) {  
const full = path.join(dir, item);  
const stat = fs.statSync(full);

if (stat.isDirectory()) {  
if (!ignored.has(item)) walk(full, out);  
} else if (/\\\\.(js|jsx|ts|tsx)$/.test(item)) {  
out.push(full);  
}  
}

return out;  
  }

  const files = fs.existsSync("src") ? walk("src") : \[\];

  console.log(JSON.stringify({  
fileCount: files.length,  
firstFiles: files.slice(0, 50)  
  }, null, 2));  
\`);

That returns the answer.  
Not the whole project.  
Same thing with logs.

y(pkg.scripts || {}, null, 2));  
'  
"  
Same thing with project shape.

ctx\_execute "bash" "  
find . \\  
  \-path './node\_modules' -prune -o \\  
  \-path './.git' -prune -o \\  
  \-path './dist' -prune -o \\  
  \-path './build' -prune -o \\  
  \-path './.next' -prune -o \\  
  \-maxdepth 3 \\  
  \-type f \\  
  | sed 's#\^./##' \\  
  | sort \\  
  | head -n 200  
"  
   
Do not feed the model the world.

Make the model ask better questions of the filesystem.

People are expecting Antigravity to work like this out of the box, but that’s not how ai works. 

Antigravity MCP config:

{  
  "mcpServers": {  
"context-mode": {  
"command": "context-mode"  
}  
  }  
}

Primary path:  
\~/.gemini/antigravity/mcp\_config.json  
Project routing file:  
GEMINI.md

Verification:  
ctx stats

Context Mode also tracks session state with a local database, so file edits, tasks, errors, git operations, and user decisions can be recovered without dumping the entire past conversation back into the prompt.

Most people are using antigravity like this:

Ask vague task.  
Let agent read everything.  
Let tool output flood context.  
Agent compacts.  
Agent forgets.  
Agent repeats.  
Token burns.  
User complains.

But the  better pattern is:

Route noisy work through Context Mode.  
Keep raw output out of context.  
Return compact results.  
Patch only what matters.

Prove the fix.  
Review before moving forward.

That is my whole game setup 

I am the GM.

The Antigravity coding agent is my Coach.

The Coach stays boxed and rule-bound and token constraint. While Gemma 4 models run locally through Ollama as my QB, with rest of the open, local, and cloud models as players on the team around it.

MCP is how the Coach reaches the outside workers.  
And Context Mode is how I stop the Coach from flooding its own context with garbage.

Native Antigravity subagents still use Antigravity tokens.  
Do not confuse that with MCP-wired tools.

If you want FREE repeated work, wire local and free workers through MCP.

If you want less context burn, use a context-control layer like Context Mode.

If you want Antigravity to work better, you gotta manage it better. 

That is how you truly reduce token burn.

The #1 MCP Setup Everyone and their LLM’s Should be Stealing Now ‼️😤