Agent skill

AI Agent

by LanternOps in LanternOps/breeze

Quick reference for the Breeze RMM AI Agent system architecture, MCP tools, streaming chat, cost tracking, guardrails, and MCP server.

AGPL-3.0Auto-check passedAgent Workflows

Install AI Agent

skills CLI
$ npx skills add LanternOps/breeze --skill ai-agent -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install LanternOps/breeze ai-agent --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/LanternOps/breeze.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/ai-agent .claude/skills/ai-agent && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
ai-agent
GitHub stars
130
Token cost
~3.7k tokens
SKILL.md length
1,143 words
Files
1
Skills in repo
14
Repo updated
First seen
Licence
AGPL-3.0

At a glance

Quick reference for the Breeze RMM AI Agent system architecture, MCP tools, streaming chat, cost tracking, guardrails, and MCP server.

  • Works in 8 steps: AI invokes a Tier 3 tool → aiAgent.ts inserts aiToolExecutions… → SSE emits approval_required event with… → …
  • Working on AI features
  • SKILL.md covers Architecture Overview, File Map, Database Schema and API Routes, plus 9 more sections
  • Calls claude

What it does

AI Agent is an agent skill from LanternOps/breeze. Quick reference for the Breeze RMM AI Agent system architecture, MCP tools, streaming chat, cost tracking, guardrails, and MCP server. Use when working on AI features, debugging chat issues, adding new tools, or understanding the AI data flow.

Its SKILL.md is about 3.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Agent Workflows, covering MCP servers and LLM cost and token optimization. It works with Model Context Protocol. The repository describes itself as: The open-source IT platform that comes with the workers. RMM + PSA in one system, with a governed AI operator built in. The licence is AGPL-3.0.

When your agent uses it

  • Working on AI features
  • Debugging chat issues
  • Adding new tools
  • Understanding the AI data flow

Example prompts

  • “/ai-agent”

Workflow steps

8 steps, taken from the first numbered list in SKILL.md.

  1. AI invokes a Tier 3 tool
  2. aiAgent.ts inserts aiToolExecutions record with status 'pending'
  3. SSE emits approval_required event with tool name, input, description
  4. Frontend shows AiApprovalDialog inline in chat
  5. User clicks Approve/Reject -> POST /sessions/:id/approve/:executionId
  6. waitForApproval() polls DB every 2s with circuit breaker (max 5 consecutive DB errors)
  7. 5-minute auto-reject timeout
  8. On approval: existing record updated to 'executing', tool runs, result returned

What it can do on your machine

Read from SKILL.md and the folder at commit 1f72bb7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • claude

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

AI Agent loads about 3.7k tokens when it runs. Until then it costs about 63 tokens; SKILL.md has 1,143 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~63
When it runs · the whole SKILL.md, loaded when a task matches
~3.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from LanternOps/breeze at commit 1f72bb7, republished under its AGPL-3.0 licence (© LanternOps). 1,143 words, ~3,739 tokens.

Download SKILL.mdSave it as .claude/skills/ai-agent/SKILL.md (or your agent's skills folder).
name
ai-agent
description
Quick reference for the Breeze RMM AI Agent system architecture, MCP tools, streaming chat, cost tracking, guardrails, and MCP server. Use when working on AI features, debugging chat issues, adding new tools, or understanding the AI data flow.

Breeze RMM AI Agent System Reference

Integrated AI agent allowing IT technicians to manage devices, troubleshoot issues, analyze security, and build automations through natural language chat.

Architecture Overview

 External Clients (Claude Desktop, Cursor)
          |  MCP over Streamable HTTP (legacy SSE kept)
          v
 +---------------------------+
 | Breeze MCP Server         |  /api/v1/mcp/*  (API Key auth)
 +---------------------------+
          |
 +------------------------------------------------------------------+
 |                     Hono API Server                               |
 |                                                                   |
 |  AI Chat Routes           MCP Server Routes                      |
 |  /api/v1/ai/*             /api/v1/mcp/*                          |
 |       |                        |                                  |
 |  +--------------------------------------------------+            |
 |  |         AI Agent Service (aiAgent.ts)             |            |
 |  |  Anthropic SDK + In-Process Tool Execution        |            |
 |  |                                                   |            |
 |  |  AI tool registry (aiTools*.ts)                   |            |
 |  |  getToolDefinitions() supplies the current tools |            |
 |  +--------------------------------------------------+            |
 |       |                    |                    |                  |
 |  Existing Services    commandQueue.ts     Event Bus (Redis)       |
 +------------------------------------------------------------------+
          |                        |
    PostgreSQL              Go Agent (on devices)

File Map

Backend (API)
FilePurpose
apps/api/src/db/schema/ai.ts5 tables: aiSessions, aiMessages, aiToolExecutions, aiCostUsage, aiBudgets
apps/api/src/services/aiAgent.tsCore agent service — session lifecycle, Anthropic API calls, SSE streaming, tool dispatch, approval polling
apps/api/src/services/aiTools.tsThe AI tool registry (~200 tools across aiTools*.ts; getToolDefinitions() is the count), with Zod schemas and org-scoped access via AuthContext.orgCondition()
apps/api/src/services/aiGuardrails.ts4-tier permission system: auto-execute, audit, approval-required, blocked
apps/api/src/services/aiCostTracker.tsToken/cost tracking, budget enforcement, rate limiting, usage summaries
apps/api/src/routes/ai.tsREST + SSE chat endpoints (/api/v1/ai/*)
apps/api/src/routes/mcpServer.tsExternal MCP server for Claude Desktop/Cursor (/api/v1/mcp/*)
Frontend (Web)
FilePurpose
apps/web/src/stores/aiStore.tsZustand store — sessions, messages, streaming, context, approval state
apps/web/src/components/ai/AiChatSidebar.tsxSlide-out panel (right side), session management, conversation history
apps/web/src/components/ai/AiChatMessages.tsxScrollable message list with markdown rendering
apps/web/src/components/ai/AiChatInput.tsxAuto-resize textarea, Cmd+Enter send
apps/web/src/components/ai/AiToolCallCard.tsxCollapsible tool invocation display with input/output
apps/web/src/components/ai/AiApprovalDialog.tsxApprove/Reject card for Tier 3 tool executions
apps/web/src/components/ai/AiContextBadge.tsxShows current page context injected into chat
apps/web/src/components/ai/AiCostIndicator.tsxToken usage + budget remaining (with polling circuit breaker)
apps/web/src/components/settings/AiUsagePage.tsxAdmin dashboard for AI usage and budget configuration
apps/web/src/pages/settings/ai-usage.astroAstro page wrapper for AI usage admin
Shared
FilePurpose
packages/shared/src/types/ai.tsTypeScript interfaces: AiSession, AiMessage, AiToolExecution, AiPageContext, AiStreamEvent
packages/shared/src/validators/ai.tsZod schemas for AI page context and message validation

Database Schema

5 tables in apps/api/src/db/schema/ai.ts:

TableKey ColumnsPurpose
ai_sessionsorgId, userId, status, model, turnCount, totalCostCentsMulti-turn conversations
ai_messagessessionId, role, content, toolName, toolInput, toolOutputMessage history
ai_tool_executionssessionId, toolName, status, approvedBy, commandIdTool audit trail
ai_cost_usageorgId, period, periodKey, inputTokens, outputTokens, totalCostCentsDaily/monthly cost aggregates
ai_budgetsorgId, enabled, monthlyBudgetCents, dailyBudgetCents, maxTurnsPerSessionPer-org budget config

Enums: ai_session_status (active/closed/expired), ai_message_role (user/assistant/system/tool_use/tool_result), ai_tool_status (pending/approved/executing/completed/failed/rejected)

API Routes

Chat Routes (/api/v1/ai/*)
MethodPathPurpose
POST/sessionsCreate session (with optional page context)
GET/sessionsList user's sessions (filterable by status)
GET/sessions/searchSearch past conversations (must be before :id route!)
GET/sessions/:idGet session with message history
DELETE/sessions/:idClose session
POST/sessions/:id/messagesSend message, returns SSE stream
POST/sessions/:id/approve/:executionIdApprove/reject tool execution
GET/usageUsage + budget summary for org
PUT/budgetUpdate budget settings
GET/admin/sessionsSession history for admin dashboard
MCP Server Routes (/api/v1/mcp/*)
MethodPathAuthPurpose
GET/sseAPI Key (ai:*)SSE transport (server→client)
POST/messageAPI Key (ai:*)JSON-RPC messages (client→server)

Session ownership validated — each SSE session tracks apiKeyId. Max 100 sessions, 30-min TTL.

SSE Stream Events

Events emitted by POST /sessions/:id/messages:

typescript
type AiStreamEvent =
  | { type: 'message_start'; messageId: string }
  | { type: 'content_delta'; delta: string }
  | { type: 'tool_use_start'; toolName: string; toolUseId: string; input: Record<string, unknown> }
  | { type: 'tool_result'; toolUseId: string; output: unknown; isError: boolean }
  | { type: 'approval_required'; executionId: string; toolName: string; input: Record<string, unknown>; description: string }
  | { type: 'message_end'; inputTokens: number; outputTokens: number }
  | { type: 'error'; message: string }
  | { type: 'done' };

MCP tools

Use the registry in apps/api/src/services/aiTools.ts (getToolDefinitions()) for the current tools and count, and the generated prompt index renderToolIndexByDomain(listChatSurfaceToolNames()) composed in apps/api/src/services/aiAgent.ts for the tools registered on the chat surface.

Helper Functions in aiTools.ts
HelperPurpose
verifyDeviceAccess(deviceId, auth, requireOnline?)Device lookup + org condition check
findAlertWithAccess(alertId, auth)Alert lookup + org condition check
getCommandQueue()Cached dynamic import of commandQueue module
getToolTier(toolName)Returns numeric tier for guardrails
executeTool(toolName, input, auth)Main dispatch — throws for unknown tools
Result envelopes (A-W05)

Every shaped list/search tool adds one additive envelope on top of its existing keys, built by the shared helper in apps/api/src/services/aiToolPagination.ts — never a bespoke per-tool shape.

  • Offset mode (readPageArgs/pageEnvelope) — stable lists (devices, tickets, patches, scripts, policies, …): limit, offset, optional cursor; result adds showing, hasMore, nextCursor (and total/totalMode where the query already counts).
  • Keyset mode (readKeysetArgs/keysetEnvelope) — churn tables where an insert between pages would shift offsets (alerts, agent logs, audit log, change log): limit, cursor (no offset); sorted (col DESC, id DESC) on a microsecond-precision timestamp column carried as text in the cursor, never round-tripped through JS Date. A cursor minted for different filters is refused with CURSOR_MISMATCH, not silently reset to page 1.
  • Both are additive: no top-level key is ever removed, and a tool is never renamed. Heavy per-row fields (jsonb settings/details, script bodies, nested sub-arrays) are dropped from the default page behind an opt-in flag (e.g. includeDetails) or left to the matching get_* detail tool, with a <key>Count in their place.
  • compactToolResultForChat (aiToolOutput.ts) learns whether a tool can page through an injected resolver (setToolPaginationHintResolver, installed by aiTools.ts after registration) — never by importing the tool registry directly. Its _chat.nextStep hint and the array-truncation sentinel only ever suggest pagination to a tool that actually supports it.
  • A new list tool: add paging with pageParamSchema()/pageZodShape() (or the keyset equivalents) on all three input-schema surfaces — the registry definition.input_schema, aiToolSchemas.ts (or aiToolSchemasFleet.ts), and the tool() Zod shape in aiAgentSdkTools.ts (plus scriptBuilderTools.ts if the tool has its own SDK shape there) — or the model gets a parameter the schema strips and pages nowhere.
  • read_artifact (aiToolsArtifacts.ts) pages a stored oversized result back by byte offset via artifact.handle in an earlier tool result. It only reads an artifact captured by the caller's own chat session or agent run (never any session of the same user), and only works on hosted deployments with the AI workspace enabled — capture stores the redacted payload, never raw. MCP tools/call has no session anchor today, so read_artifact called over MCP typically refuses with no_capture_anchor.
Show full SKILL.md (336 more words)Show less

Guardrails (4-Tier System)

Defined in aiGuardrails.ts:

TierBehaviorExamples
1Auto-executequery_devices, get_device_details, analyze_metrics, query_audit_log
2Auto-execute + audit logmanage_alerts(acknowledge/resolve), manage_services(list)
3Requires user approval (5-min timeout)execute_command, run_script, file writes, service start/stop
4BlockedUnknown tools, auth modifications

Action-based escalation: TIER3_ACTIONS maps tool+action combos that escalate (e.g., file_operations.write escalates from T1 to T3).

Approval Flow

  1. AI invokes a Tier 3 tool
  2. aiAgent.ts inserts aiToolExecutions record with status 'pending'
  3. SSE emits approval_required event with tool name, input, description
  4. Frontend shows AiApprovalDialog inline in chat
  5. User clicks Approve/Reject -> POST /sessions/:id/approve/:executionId
  6. waitForApproval() polls DB every 2s with circuit breaker (max 5 consecutive DB errors)
  7. 5-minute auto-reject timeout
  8. On approval: existing record updated to 'executing', tool runs, result returned

Cost Tracking

In aiCostTracker.ts:

FunctionPurpose
calculateCostCents(model, inputTokens, outputTokens)Claude pricing math
checkBudget(orgId)Pre-message budget check (fails closed on DB errors)
checkAiRateLimit(userId, orgId)20 msg/min per user, 200 msg/hr per org
recordUsage(sessionId, orgId, model, inputTokens, outputTokens, isToolExecution)Atomic transaction: session update + daily/monthly aggregate upserts
updateBudget(orgId, settings)Upsert budget configuration
getUsageSummary(orgId)Daily + monthly usage + budget for admin dashboard
getSessionHistory(orgId, { limit, offset })Session list for admin

Model pricing (cents per million tokens):

  • claude-sonnet-4-5-20250929: 300 input / 1500 output
  • claude-haiku-4-5-20251001: 100 input / 500 output

Page Context Injection

Frontend pushes context to aiStore.setPageContext():

typescript
type AiPageContext =
  | { type: 'device'; id: string; hostname: string; os?: string; status?: string; ip?: string }
  | { type: 'alert'; id: string; title: string; severity?: string; deviceHostname?: string }
  | { type: 'dashboard'; orgName?: string; deviceCount?: number; alertCount?: number }
  | { type: 'custom'; label: string; data: Record<string, unknown> };

Context is injected into the system prompt and sent with each message. The AiContextBadge component shows it visually in the chat header.

Data Flow: Chat Message

1. User types message in AiChatInput
2. aiStore.sendMessage(content)
   - Creates session if needed (POST /sessions)
   - Adds user message optimistically
   - POST /sessions/:id/messages with SSE stream
3. API receives message
   - checkAiRateLimit() — fail closed on Redis error
   - checkBudget() — fail closed on DB error
   - Insert user message to ai_messages
   - Build Anthropic messages array from conversation history
   - Call Anthropic API with tools + system prompt
4. Stream processing (generator function)
   - Yield message_start, content_delta events
   - On tool_use: check guardrails
     - Tier 1-2: execute immediately
     - Tier 3: insert execution record, yield approval_required, wait
     - Tier 4: return error
   - Yield tool_result events
   - On message_end: recordUsage() in transaction
   - Yield done
5. Frontend processes SSE events via processStreamEvent()
   - Updates Zustand store incrementally
   - Shows tool cards, approval dialogs, streaming text

Key Patterns & Safety

  • Fail-closed: Rate limit and budget checks deny requests when Redis/DB is down
  • Circuit breaker: waitForApproval breaks after 5 consecutive DB poll failures
  • ILIKE escaping: escapeLike() helper prevents SQL wildcard injection in search
  • Transaction wrapping: recordUsage uses db.transaction() for atomicity
  • Session ownership: MCP SSE sessions track apiKeyId to prevent cross-session injection
  • Polling circuit breaker: AiCostIndicator stops after 5 failures or auth errors
  • Route ordering: /sessions/search registered before /sessions/:id in Hono
  • No dual records: Approval flow updates existing execution record instead of creating a second one

Connecting External Clients

bash
# Claude Code MCP connection
claude mcp add --transport http breeze-rmm https://your-breeze-instance.example.com/api/v1/mcp/sse \
  --header "X-API-Key: brz_your_api_key_here"

API key needs ai:read, ai:write, or ai:execute scopes.

© LanternOps, AGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/ai-agent of LanternOps/breeze.

Open the folder on GitHubat commit 1f72bb7

Compare with similar skills

AI Agent next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

AI Agent compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
AI Agent this skillLanternOps/breeze130—~3.7kAutomated safety check: PassAGPL-3.0
Context Mode Output Sandboxmksglu/context-mode26k—~4.1kAutomated safety check: PassCustom licence
Context Mode for Antigravity CLImksglu/context-mode26k—~850Automated safety check: PassCustom licence
Connectactiveing123/mcptoon2141 repos~701Automated safety check: PassApache-2.0
Entroly Context Controljuyterman1000/entroly472—~501Automated safety check: PassApache-2.0
Authoringactiveing123/mcptoon214—~559Automated safety check: PassApache-2.0

Similar skills

  • Context Mode Output Sandbox

    mksglu/context-mode

    Routes large command, file, API and browser output through context-mode tools so only the needed result enters the agent's context, instead of dumping it via Bash.

    26k GitHub stars~4.1k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Routing rules for using context-mode MCP tools in Antigravity CLI: sandboxed code runs, file analysis, indexed search and web fetches that keep large output out of the conversation.

    26k GitHub stars~850 tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Connect

    activeing123/mcptoon

    Connect any AI agent to MCP servers through mcptoon — one config synced everywhere, one stdio gateway, 99.2% fewer tokens on tool discovery.

    214 GitHub starsUsed in 1 repo~701 tokens
    Agent WorkflowsAuto-check passed
  • Entroly Context Control

    juyterman1000/entroly

    Surgically select, compress, and recover codebase context using Entroly's MCP tools.

    472 GitHub stars~501 tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Authoring

    activeing123/mcptoon

    Add or edit an MCP server entry in mcptoon's config correctly — stdio/streamable-http/sse shapes, command rules, placeholders, and validation.

    214 GitHub stars~559 tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Entroly Lobehub Audit

    juyterman1000/entroly

    Audit and remediate Entroly's MCP marketplace quality with evidence, adversarial validation, and no score gaming.

    472 GitHub stars~1.2k tokensUpdated today
    Agent WorkflowsAuto-check passed

More from LanternOps/breeze

All 14 skills in this repo
  • Agent Info

    LanternOps/breeze

    Quick reference for the Breeze RMM Go agent architecture, commands, configuration, build process, and data flows.

    130 GitHub stars~4.7k tokensUpdated today
    Auto-check: notes
  • Agent Log Debugging

    LanternOps/breeze

    A skill your agent uses when debugging agent issues, investigating agent errors, checking agent connectivity, or reviewing agent diagnostic logs.

    130 GitHub stars~1.6k tokensUpdated today
    Auto-check: notes
  • Breeze Helper

    LanternOps/breeze

    Quick reference for the Breeze Helper Tauri desktop app — architecture, Rust backend commands, React frontend, config files, IPC with the Go agent, helper chat API routes, tool approval flow, and…

    130 GitHub stars~3.2k tokensUpdated today
    Auto-check passed
  • E2E Coverage

    LanternOps/breeze

    A skill your agent uses when running a broad manual/AI-driven end-to-end verification of Breeze RMM across many merged PRs or commits — "test everything since the last release", release-readiness…

    130 GitHub stars~1.6k tokensUpdated today
    Auto-check passed
  • Feature Delivery

    LanternOps/breeze

    A skill your agent uses when orchestrating Breeze implementation work from this seat — dispatching waves or issue fixes to background sessions, deciding whether an open PR gets merged, handling a…

    130 GitHub stars~2.8k tokensUpdated today
    Auto-check passed
  • Gh Queue

    LanternOps/breeze

    A skill your agent uses when reviewing, triaging, or managing the incoming GitHub backlog on the Breeze repo — PRs, Discussions, AND Issues.

    130 GitHub stars~5k tokensUpdated today
    Auto-check passed

Questions about AI Agent

What does AI Agent do?

Quick reference for the Breeze RMM AI Agent system architecture, MCP tools, streaming chat, cost tracking, guardrails, and MCP server. AI Agent is an agent skill from LanternOps/breeze. Quick reference for the Breeze RMM AI Agent system architecture, MCP tools, streaming chat, cost tracking, guardrails, and MCP server.

When should I use AI Agent?

AI Agent fits situations like: working on AI features; debugging chat issues; adding new tools; understanding the AI data flow.

How do I install AI Agent in Claude Code?

Run `npx skills add LanternOps/breeze --skill ai-agent -a claude-code`. Or copy the skill folder (.claude/skills/ai-agent in LanternOps/breeze) into .claude/skills/ai-agent in your project. Claude Code loads it when a task matches its description.

How do I install AI Agent in Codex?

Run `npx skills add LanternOps/breeze --skill ai-agent -a codex`. Or copy the skill folder (.claude/skills/ai-agent in LanternOps/breeze) into .agents/skills/ai-agent in your project. Codex loads it when a task matches its description.

Can I use AI Agent in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add LanternOps/breeze --skill ai-agent -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/ai-agent, .gemini/skills/ai-agent, .github/skills/ai-agent and .opencode/skills/ai-agent in your project.

What does AI Agent need to run?

Going by SKILL.md and its folder, AI Agent needs the command-line tools its instructions call (claude).

Does AI Agent access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is AI Agent safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does AI Agent use?

AI Agent is published under the AGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does AI Agent use?

About 3.7k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to AI Agent?

Skills that share tags, products or a category with AI Agent: Context Mode Output Sandbox (mksglu/context-mode, 26k stars), Context Mode for Antigravity CLI (mksglu/context-mode, 26k stars), Connect (activeing123/mcptoon, 214 stars) and Entroly Context Control (juyterman1000/entroly, 472 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains AI Agent?

LanternOps (a GitHub organization) maintains it in LanternOps/breeze, which has 130 GitHub stars. The repository holds 14 skills in this directory. The repository was last updated on October 7, 2026.

Source: LanternOps/breeze on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.