Author: Robina Mirbahar — Google Developer Expert (Cloud & GenAI) | Published Author of AI Engineering | GitHub Open Source
Reading, auditing, and explaining dense machine learning or engineering papers shouldn't stop at a wall of plain-text chat bullets—or brittle LaTeX scripts that break on half of developer workstations.
Over the past week, I architected and open-sourced My-antigravity-research-skills (agy-research-kit), a full-stack Google Antigravity Plugin built with Google Antigravity for rigorous scientific paper auditing, interactive simulation, and visual storytelling.
🔗 GitHub Repository: https://github.com/RobinaMirbahar/My-antigravity-research-skills
🎮 Live HTML5 Interactive Paper Simulator: https://robinamirbahar.github.io/My-antigravity-research-skills/
Why Native Google Antigravity Primitives Change Research Workflows
Google Antigravity gives developers five composable customization layers that fit together cleanly:
-
Progressive-Disclosure Skills (
SKILL.md): Each skill sits idle at~50 tokens(YAML frontmatter only) until the agent actually needs it—preventing context bloat across 8+ specialized workflows. -
Stdio MCP Servers (
mcp_config.json): Zero-hallucination deterministic tools for statistical hypothesis tests and live Crossref DOI lookups. -
Lifecycle Safety Hooks (
hooks.json): Pre/post tool-call guards that stop common Python research bugs before they happen. -
Always-On Rules (
rules/AGENTS.md): Strict provenance rules ensuring zero invented metrics and mandatory visual montage QA. - Interactive HTML5 Studios: Self-contained 60-FPS Canvas/SVG parameter explorers that let readers drag sliders over a paper's equations in real time.
Inside the 8 agy-* Research Skills
Every script in agy-research-kit uses PEP 723 inline # /// script metadata executed via uv run, plus headless Chromium/Edge and pymupdf + imageio[ffmpeg]—meaning zero system TeX or global FFmpeg installation headaches across Windows, macOS, and Linux:
| Skill | What It Builds | Output Artifact |
|---|---|---|
agy-interactive-paper-studio |
Turns closed-form paper equations into a zero-backend 60-FPS HTML5/Canvas simulator | Standalone index.html
|
agy-ablation-stat-auditor |
Recomputes exact Wilson 95% score CIs, Fisher's Exact, McNemar paired p-values, & leaderboard noise floors | Audit Markdown/LaTeX + JSON |
agy-citation-doi-verifier |
Verifies bibliographies against live Crossref & OpenAlex REST APIs and upgrades preprints to published venues | Traffic-Light DOI Audit |
agy-figure-forensics |
Adds numbered vector callouts, regime shading, and Engineering Takeaway cards onto 300-DPI paper plots | A4 Visual Anatomy PDF |
agy-math-sandbox |
Color-codes equations into operator blocks and runs deterministic NumPy/SciPy Monte Carlo verification | A4 Math Verification PDF |
agy-trajectory-cinematics |
Renders 1920x1080 H.264 .mp4 animations pairing a live system state monitor with 2x2 real-time telemetry curves |
1080p .mp4 + Narration .md
|
agy-graphic-story |
Renders pure-code A4 Vector SVG Technical Graphic Novels with custom characters, blackboards, and verbatim scoreboards | A4 Vector Comic PDF |
agy-frontier-gap-radar |
Orchestrates OpenAlex + arXiv retrieval into an N x 7 capability heatmap and novelty-checked research blueprints |
A4 Frontier Gap Radar PDF |
Live Sample Showcase: Dissecting Quantized Agent Context Collapse (Gemma 4 LoopBreaker)
To test all 8 skills end-to-end on a real systems research problem, the repository includes a complete showcase in examples/gemma4-loop-breaker/ analyzing how 4-bit weight quantization (W4A16) interacts with growing multi-turn agent KV caches (1 - 1 / (1 + C * e^{-delta})).
1. Pure-Code Vector SVG Technical Graphic Story (agy-graphic-story)
Generated 100% programmatically from Python + SVG/HTML (story_svg_engine.py) with verbatim benchmark tables and automatic PyMuPDF 2-up visual QA:
📄 Download Full Sample PDFs Directly from the Repo:
- 4-Page Vector Graphic Story PDF: Gemma4_LoopBreaker_Comic_v1.pdf
- Visual Figure Forensics Dossier PDF: Gemma4_LoopBreaker_Figure_Guide_v1.pdf
- Color-Coded Equation & Monte Carlo Verification PDF: Gemma4_LoopBreaker_Equation_Guide_v1.pdf
2. 1080p Animated Telemetry Explainer (agy-trajectory-cinematics)
Using imageio[ffmpeg] inside an isolated uv run micro-environment, the plugin renders a crisp 1920x1080 H.264 .mp4 sweep synchronizing an agent state monitor with four live quantitative plots:
🎬 Watch / Stream Full 1080p .mp4: https://robinamirbahar.github.io/My-antigravity-research-skills/Gemma4_LoopBreaker_Explainer_v1.mp4
Built-In Stdio MCP Server & Lifecycle Safety Hook
When you install plugins/agy-research-kit, Antigravity automatically registers two guardrails that keep AI research honest:
-
research_audit_mcp.py(Stdio MCP Server): Exposesverify_wilson_ci,verify_fisher_exact,leaderboard_noise_floor, andverify_doi_metadataover JSON-RPC so the agent never guesses confidence intervals or p-values mentally. -
stdlib_shadow_guard.py(PostToolUseHook): Catches a classic Python footgun—if a script tries to writenumbers.py,statistics.py, ormath.pyin your working directory (which silently crashesnumpyandscipy), the hook flags it immediately.
Install in 30 Seconds
Windows (PowerShell):
git clone https://github.com/RobinaMirbahar/My-antigravity-research-skills.git
New-Item -ItemType Directory -Force -Path "$HOME\.gemini\config\plugins" | Out-Null
Copy-Item -Recurse -Force My-antigravity-research-skills\plugins\agy-research-kit "$HOME\.gemini\config\plugins\"
macOS / Linux:
git clone https://github.com/RobinaMirbahar/My-antigravity-research-skills.git
mkdir -p ~/.gemini/config/plugins
cp -r My-antigravity-research-skills/plugins/agy-research-kit ~/.gemini/config/plugins/
Run the self-contained verification suite anytime with:
uv run tests/test_skills_structure.py
If you try agy-research-kit on your own papers or Kaggle competition writeups, drop a star on RobinaMirbahar/My-antigravity-research-skills and let me know what research skill you'd love to see next!
💬 Community Discussion & Feedback
Have you experimented with custom Model Context Protocol (MCP) servers, research sandboxes, or agent skills in your workflow yet?
What is the biggest friction point you face when building autonomous AI research or developer pipelines?Drop your thoughts, questions, or ideas below — I'd love to discuss and collaborate! 👇




Top comments (4)
I'm using Antigravity too, and putting statistical checks into research_audit_mcp.py instead of letting the model guess p-values in plain text hits close to home. Whenever I ask an agent to summarize numbers or check math without a real script backing it up, it sounds completely confident even when the calculation is off. Splitting things into small SKILL.md files that only load when needed also feels way more manageable than dumping everything into one giant prompt.
100% agreed, @whatthecode1234! That "confidently wrong" trap on numerical math is exactly what inspired
research_audit_mcp.py.Because autoregressive LLMs predict tokens based on statistical likelihood rather than running an actual arithmetic register, asking them to compute confidence intervals or Fisher's Exact tests in plain text almost always yields plausible-sounding hallucinations. Binding the model to a deterministic Python sandbox via stdio MCP turns the agent from a guesser into an orchestrator that verifies its own derivations with real code.
And on the progressive disclosure front: keeping each
SKILL.mdidle at ~50 tokens (just YAML frontmatter) until the agent genuinely needs it has been a game-changer for avoiding context drift and token bloat across multi-step research tasks.Glad to meet another Antigravity builder! What kind of skills or workflows are you experimenting with in your setup?
Nothing nearly as advanced as a full research kit yet. Right now I'm mostly using Antigravity for smaller day-to-day coding tasks and learning how to keep my instructions organized without overloading the context. Seeing how you structured your SKILL.md files actually gave me a clearer idea of how to split up my own workflows instead of repeating the same rules every session.
Thanks so much, @whatthecode1234 That honestly means a lot.
You hit on the exact pain point that led me to this design. When you dump everything into one monolithic system prompt or master rulebook, two things inevitably happen:
Context Bloat & Instruction Drift: The agent has so many competing constraints in its active window that it starts softly ignoring the rules that actually matter.
Confident Hallucination: Plain-text LLMs will gladly "solve" an equation or compute a p-value with total confidence and zero mathematical validity.
Even for day-to-day coding workflows (like Git hygiene, API mocking, testing, or Docker setups), treating your instructions as progressive-disclosure skills is a game changer. Keep each SKILL.md focused on one distinct job with clear triggers, so the model only pulls those tokens into context when you actually ask for that specific task.
If you ever want to bounce ideas around on structuring your first set of custom skills or MCP tools for your daily stack, let me know. Happy to share templates! 🚀