GravityBoots

Transparent agentic automation you can actually audit.

Your persistent intelligence layer — extending your IDE into an ambient automation command center that watches, learns, and acts on your behalf, with every decision visible, every execution logged, and every line of code readable.

Why GravityBoots

AI agents are powerful. But you can't see what they do, you can't control what they spend, and you can't audit what they decided. GravityBoots changes that.

Every automation in GravityBoots is a boot skill — a self-contained Python file that carries its own documentation, its own permissions manifest, and its own nutrition label: an auto-generated trust profile declaring exactly what the skill consumes, costs, produces, and risks. Before it runs, you know what it will do. After it runs, you can trace every step.

No black boxes. No opaque reasoning. No surprise API bills.

Features

🤖 Boot Skills — Persistent, Auditable Automation

Self-contained Python modules that run on schedules, respond to events, and maintain state across sessions. Each skill is a readable .py file — not a plugin binary, not a containerized microservice. You can read every line, modify any behavior, and version-control every change.

🏷️ Nutrition Labels — Trust Before Execution

Every boot skill carries an auto-generated nutrition label — like food packaging for automation. At a glance you see: what APIs it calls, what data it reads, what it costs per run, what model it uses, and what permissions it needs. The nutrition label is generated from the code and embedded in the code. No external trust registry required.

💬 Concierge — Memory-Aware Conversational Interface

A persistent chat interface that connects you to your automation layer. The concierge remembers what happened yesterday, learns your preferences over time, and can create, modify, and manage boot skills through natural conversation. Direct your automation in plain English.

🔍 Full Execution Trace

Every execution — from the event that triggered it, to the LLM call that made a decision, to the action that followed — is visible in the trace viewer. Drill into any run to see exactly what happened and why.

💰 Cost Transparency

Real-time token metering with per-skill, per-model, and per-session cost tracking. Set budgets, get alerts, and never be surprised by an API bill again.

🧠 Compounding Memory

Typed memory (semantic, episodic, procedural) that captures context from every interaction and execution. The system gets smarter from what it does, not just what it's told.

🛡️ Security-First Architecture

Skills declare their permissions upfront. The audit pipeline verifies them. Trust tiers (sandboxed → verified → autonomous) gate what skills can do. You approve escalations explicitly.

Getting Started

1. Install the Extension

Click Install above, or search GravityBoots in your IDE's Extensions panel.

2. Open a Workspace

Open any folder in your IDE. GravityBoots will detect whether it's been initialized.

3. Follow the Prompts

The extension guides you through setup:

• Python package — one-click install of the gravityboots daemon
• Browser automation — Chromium installed automatically for web-capable skills
• Daemon startup — the background service starts and connects automatically

Look for "Boots: Connected" in the status bar. You're operational.

4. Open the System Panel

Ctrl+Shift+P → Boots: Welcome to see your system status, services, environment, and available actions.

Requirements

An LLM API key is needed for skills that use language models:

Commands

How It Works

┌─────────────────────────────────────────────────┐
│  Your IDE (VS Code / Antigravity / Cursor)      │
│  ┌───────────────────────────────────────────┐  │
│  │  GravityBoots Extension                   │  │
│  │  • Sidebar: skill tree, nutrition labels  │  │
│  │  • Chat: concierge interface              │  │
│  │  • Panels: traces, costs, system status   │  │
│  └──────────────────┬────────────────────────┘  │
│                     │ JSON-RPC                   │
│  ┌──────────────────▼────────────────────────┐  │
│  │  Boots Daemon (Python, background)        │  │
│  │  • Orchestration engine                   │  │
│  │  • Scheduler, memory, state               │  │
│  │  • LLM service, browser service           │  │
│  │  • Audit pipeline                         │  │
│  └──────────────────┬────────────────────────┘  │
│                     │                            │
│  ┌──────────────────▼────────────────────────┐  │
│  │  .boots/skills/*.py                       │  │
│  │  Your boot skills — readable, editable    │  │
│  └───────────────────────────────────────────┘  │
└─────────────────────────────────────────────────┘

The extension is the visual layer. The daemon is the engine. The skills are the intelligence — captured in code, not rented per execution.

The Externalization Thesis

Most AI tools rent intelligence on every execution — you pay per call, per token, per run. The intelligence evaporates when the session ends.

GravityBoots captures intelligence in code once. A boot skill encodes the reasoning, the error handling, the domain logic, and the operational decisions in a Python file that runs forever at near-zero marginal cost. The LLM helped write it. Now it doesn't need to be called again.

That's the externalization dividend: intelligence that compounds instead of depreciating.

License

Apache 2.0 — © 2026 Evodio Walle

Because a closed-source product can't create a category.