ag-refresh builds a knowledge base. ag-ask answers questions. It uses the calling main agent's LLM capability, so no extra provider key is required.
Language: English | 涓枃 | Espa帽ol
An AI Agent's capability ceiling = the quality of context it can read.
The engine is the core: ag-refresh scans and groups your code, then exposes structured prompts, schemas, and acceptance criteria to the calling main agent. The main agent launches sub-agents when available, or falls back to its own LLM capability, to generate module knowledge docs. ag-ask routes questions to the right Agent, grounded in real code with file paths and line numbers.
Instead of handing Claude Code / Codex a repo-wide grep and making it hunt on its own, give it a ChatGPT for your repository.
Tested on OpenClaw (12K files, 348K stars) with MiniMax2.7 鈥?module Q&A scored 10/10, 111 modules self-learned in 43 minutes. See full eval below.
Traditional approach: Antigravity approach:
CLAUDE.md = 5000 lines of docs Claude Code calls ask_project("how does auth work?")
Agent reads it all, forgets most Router 鈫?ModuleAgent reads actual source, returns exact answer
Hallucination rate stays high Grounded in real code, file paths, and git history
| Problem | Without Antigravity | With Antigravity |
|---|---|---|
| Agent forgets coding style | Repeats the same corrections | Reads .antigravity/conventions.md 鈥?gets it right the first time |
| Onboarding a new codebase | Agent guesses at architecture | ag-refresh 鈫?ModuleAgents self-learn each module |
| Switching between IDEs | Different rules everywhere | One .antigravity/ folder 鈥?every IDE reads it |
| Asking "how does X work?" | Agent reads random files | ask_project MCP 鈫?Router routes to the responsible ModuleAgent |
Architecture is files + a live Q&A engine, not plugins. Portable across any IDE, any LLM, zero vendor lock-in.
Option A 鈥?Engine: multi-agent Q&A on your codebase (recommended)
# 1. Install engine + CLI
pip install "git+https://github.com/study8677/antigravity-workspace-template.git#subdirectory=cli"
pip install "git+https://github.com/study8677/antigravity-workspace-template.git#subdirectory=engine"
# 2. No OpenAI/Gemini/Ollama key or model setup is required.
# Semantic refresh uses the LLM capability of the main agent that calls it.
cd my-project
# 3. Build knowledge base (ModuleAgents self-learn each module)
ag-refresh --workspace .
# 4. Ask anything
ag-ask "How does auth work in this project?"
# 5. (Optional) Register as MCP server for Claude Code
claude mcp add antigravity ag-mcp -- --workspace $(pwd)
# The MCP host/main agent will run refresh tasks with sub-agents when available.LLM delegation model: Antigravity no longer reads local LLM provider keys from .env. The middleware scans the project, preloads source context, and returns task packages (prompt, schema, result_contract, acceptance criteria) to the embedding main agent. The main agent should run those tasks with sub-agents when available; if no sub-agent exists, it uses its own LLM on the supplied prompt. Antigravity then validates and persists the submitted results into .antigravity/.
Option B 鈥?Context files only (any IDE, no LLM needed)
pip install git+https://github.com/study8677/antigravity-workspace-template.git#subdirectory=cli
ag init my-project && cd my-project
# IDE entry files bootstrap into AGENTS.md; dynamic knowledge is in .antigravity/ ag init Inject context files into any project (--force to overwrite)
鈹? 鈻? .antigravity/ Shared knowledge base 鈥?every IDE reads from here
鈹? 鈹溾攢鈹€鈻?ag-refresh Dynamic multi-agent self-learning 鈫?module knowledge docs + structure map
鈹溾攢鈹€鈻?ag-ask Router 鈫?ModuleAgent Q&A with live code evidence
鈹斺攢鈹€鈻?ag-mcp MCP server 鈫?Claude Code calls directly
Dynamic Multi-Agent Cluster 鈥?During ag-refresh, the engine uses smart functional grouping: files are grouped by import relationships, directory co-location, and filename prefixes. Source code is pre-loaded directly into agent context (no tool calls needed), and build artifacts are automatically filtered out. Each sub-agent analyzes ~30K tokens of focused, functionally related code in a single LLM call and outputs a comprehensive Markdown knowledge document (agents/*.md). For large modules, multiple sub-agents run in parallel 鈥?each produces its own agent.md (no merging, no information loss). A Map Agent reads all agent docs and generates map.md 鈥?a routing index. During ag-ask, Router reads map.md to select relevant modules, then feeds their agent docs to answer agents. For structural questions (call chains, dependencies, impact analysis), the Router automatically queries GitNexus code graph for precise relationships. Fully language-agnostic 鈥?module detection uses pure directory structure, code analysis is done entirely by LLMs. Works with any programming language.
GitAgent 鈥?A dedicated agent for analyzing git history 鈥?understands who changed what and why.
GitNexus Graph Enrichment (optional) 鈥?Install GitNexus to auto-unlock graph-enriched answers. The Router LLM decides when a question needs structural analysis (call chains, dependencies, impact) and queries GitNexus automatically 鈥?combining precise graph data with semantic understanding from agent docs.
NLPM Audit Feedback 鈥?This repository has benefited from NLPM, a natural-language programming linter for Claude Code plugins, skills, and agent definitions by xiaolai. Its audit helped identify useful improvements in skill frontmatter and dependency hygiene.
| Command | What it does | LLM source |
|---|---|---|
ag init <dir> |
Inject cognitive architecture templates | None |
ag init <dir> --force |
Re-inject, overwriting existing files | None |
ag refresh --workspace <dir> |
CLI convenience wrapper around the knowledge-hub refresh pipeline | Calling main agent when embedded |
ag ask "question" --workspace <dir> |
CLI convenience wrapper around the routed project Q&A flow | Calling main agent when embedded |
ag-refresh |
Multi-agent self-learning of codebase, generates module knowledge docs + conventions.md + structure.md |
Calling main agent when embedded |
ag-ask "question" |
Router 鈫?ModuleAgent/GitAgent routed Q&A | Calling main agent when embedded |
ag-mcp --workspace <dir> |
Start MCP server 鈥?exposes ask_project + refresh_project to Claude Code |
Host main agent |
ag report "message" |
Log a finding to .antigravity/memory/ |
None |
ag log-decision "what" "why" |
Log an architectural decision | None |
ag ask / ag refresh are available when both cli/ and engine/ are installed. ag-ask / ag-refresh are the engine-only entrypoints.
antigravity-workspace-template/
鈹溾攢鈹€ cli/ # ag CLI 鈥?lightweight, pip-installable
鈹? 鈹斺攢鈹€ templates/ # .cursorrules, CLAUDE.md, .antigravity/, ...
鈹斺攢鈹€ engine/ # Multi-agent engine + Knowledge Hub
鈹斺攢鈹€ antigravity_engine/
鈹溾攢鈹€ _cli_entry.py # ag-ask / ag-refresh / ag-mcp + python -m dispatch
鈹溾攢鈹€ config.py # Pydantic configuration
鈹溾攢鈹€ hub/ # 鈽?Core: multi-agent cluster
鈹? 鈹溾攢鈹€ agents.py # Router + ModuleAgent + GitAgent
鈹? 鈹溾攢鈹€ contracts.py # Pydantic models: claims, evidence, refresh status
鈹? 鈹溾攢鈹€ ask_pipeline.py # agent.md + graph-enriched ask
鈹? 鈹溾攢鈹€ refresh_pipeline.py # LLM-driven refresh 鈫?agents/*.md + map.md
鈹? 鈹溾攢鈹€ ask_tools.py
鈹? 鈹溾攢鈹€ scanner.py # multi-language project scanning
鈹? 鈹溾攢鈹€ module_grouping.py # smart functional file grouping
鈹? 鈹溾攢鈹€ structure.py
鈹? 鈹溾攢鈹€ knowledge_graph.py
鈹? 鈹溾攢鈹€ retrieval_graph.py
鈹? 鈹斺攢鈹€ mcp_server.py
鈹溾攢鈹€ mcp_client.py # MCP consumer (connects external tools)
鈹溾攢鈹€ memory.py # Persistent interaction memory
鈹溾攢鈹€ tools/ # MCP query tools + extensions
鈹溾攢鈹€ skills/ # Skill loader
鈹斺攢鈹€ sandbox/ # Code execution (local / microsandbox)
CLI (pip install .../cli) 鈥?Zero LLM deps. Injects templates, logs reports & decisions offline.
Engine (pip install .../engine) - Multi-agent runtime. Powers ag-ask, ag-refresh, ag-mcp. It does not require local LLM provider configuration; semantic work is delegated to the calling main agent's LLM capability.
New skill packaging updates:
engine/antigravity_engine/skills/graph-retrieval/鈥?graph-oriented retrieval tools for structure and call-path reasoning.engine/antigravity_engine/skills/knowledge-layer/鈥?project knowledge-layer tools for semantic context consolidation.
# Install both for full experience
pip install "git+https://...#subdirectory=cli"
pip install "git+https://...#subdirectory=engine"For local work on this repository itself:
python3 -m venv venv
source venv/bin/activate
pip install -e ./cli -e './engine[dev]'
pytest engine/tests cli/testsag init my-project
# Already initialized? Use --force to overwrite:
ag init my-project --forceCreates AGENTS.md (authoritative behavior rules), IDE bootstrap files (.cursorrules, CLAUDE.md, .windsurfrules, .clinerules, .github/copilot-instructions.md), and .antigravity/ dynamic context files.
ag-refresh --workspace my-project9-step pipeline:
- Scan codebase (languages, frameworks, structure)
- Multi-agent pipeline generates
conventions.md - Generate
structure.md鈥?language-agnostic file tree with line counts - Build knowledge graph (
knowledge_graph.json+ mermaid) - Write document/data/media indexes
- Host-agent semantic analysis - group files by import graph + directory + prefix, pre-load source context, and expose prompts, schemas, result contracts, and acceptance criteria to the calling main agent. The main agent runs sub-agents when available; otherwise it uses its own LLM. Antigravity validates the submitted JSON/Markdown before writing
agents/*.mdand structured knowledge. - RefreshGitAgent analyzes git history, generates
_git_insights.md - Map Agent reads all agent docs 鈫?generates
map.md(module routing index with descriptions and key topics) - GitNexus indexing (optional) 鈥?runs
gitnexus analyzeto build a Tree-sitter code graph (16 languages, call chains, dependencies). Auto-skipped if GitNexus is not installed.
ag-ask "How does auth work in this project?"The ask pipeline uses a dual-path architecture:
- Semantic path: Router reads
map.md鈫?selects modules 鈫?readsagents/*.md鈫?LLM answers with code references. Multiple agent docs are read in parallel, then a Synthesizer combines answers. - Graph path (automatic): Router LLM decides if the question needs structural analysis 鈫?queries GitNexus for call chains, dependencies, or impact 鈫?injects graph data into the answer context. Silently skipped if GitNexus is not installed.
Falls back to the legacy Router 鈫?ModuleAgent/GitAgent swarm when agent docs are not yet generated.
Architecture is encoded in files 鈥?any agent that reads project files benefits:
| IDE | Config File |
|---|---|
| Cursor | .cursorrules |
| Claude Code | CLAUDE.md |
| Windsurf | .windsurfrules |
| VS Code + Copilot | .github/copilot-instructions.md |
| Gemini CLI / Codex | AGENTS.md |
| Cline | .clinerules |
| Google Antigravity | .antigravity/rules.md |
All are generated by ag init: AGENTS.md is the single behavioral rulebook, IDE-specific files are thin bootstraps, and .antigravity/ stores shared dynamic project context.
MCP Server 鈥?Give Claude Code a ChatGPT for your codebase
Instead of reading hundreds of documentation files, Claude Code can call ask_project as a live tool 鈥?backed by a dynamic multi-agent cluster: Router routes questions to the right ModuleAgent, returning grounded answers with file paths and line numbers.
Setup:
# Install engine
pip install "git+https://github.com/study8677/antigravity-workspace-template.git#subdirectory=engine"
# Register as MCP server in Claude Code
claude mcp add antigravity ag-mcp -- --workspace /path/to/project
# Then ask the host agent to call refresh_project.
# It will receive task packages, run sub-agents when available, submit results,
# and finalize the knowledge base without any Antigravity LLM keys.Tools exposed to Claude Code:
| Tool | What it does |
|---|---|
ask_project(question) |
Router 鈫?ModuleAgent/GitAgent answers codebase questions. Returns file paths + line numbers. |
refresh_project(quick?) |
Rebuild knowledge base after significant changes. ModuleAgents re-learn the code. |
Dynamic Multi-Agent Cluster 鈥?Module-level self-learning + intelligent routing
The engine's core is a dynamically created Agent cluster per code module:
ag-refresh: ag-ask:
For each module: Router (reads map.md)
鈹?Group files by import graph 鈹溾攢鈹€ GRAPH: no 鈫?read agents/*.md 鈫?LLM answer
鈹?Pre-load ~30K tokens per sub-agent 鈹斺攢鈹€ GRAPH: yes 鈫?query GitNexus graph
鈹?Filter out build artifacts 鈫?graph data + agents/*.md 鈫?LLM answer
鈹?Sub-agents 鈫?Markdown agent docs
鈹?agents/{module}.md (or /group_N.md)
鈹?Map Agent 鈫?map.md
鈹?GitNexus analyze (optional)
Key innovations:
- Host-agent LLM as analyzer: no local provider key is needed. Source context is packaged into tasks for the calling main agent, which can delegate to sub-agents or use its own LLM.
- Smart grouping: Files grouped by import relationships, directory co-location, and filename prefixes. Build artifacts automatically filtered out. Hard character limit (800K) prevents context overflow.
- No information loss: Large modules produce multiple
agent.mdfiles (one per group) 鈥?no merging or compression. Duringag-ask, multiple agent docs are read by parallel LLM calls, then a Synthesizer combines answers. - Graph-enriched answers: Router LLM automatically decides when a question needs structural data (call chains, dependencies, impact) and queries GitNexus. Combines precise graph relationships with semantic understanding.
- Host-managed concurrency: provider limits are handled by the host AI agent; Antigravity only exposes task packages and validates results.
- Language-agnostic module detection: Pure directory structure 鈥?no
__init__.pyor any language-specific marker required.
# ModuleAgents self-learn your codebase
ag-refresh
# Only scan files changed since last refresh
ag-refresh --quick
# Router intelligently routes to the right ModuleAgent
ag-ask "What testing patterns does this project use?"
# Log findings and decisions (no LLM needed)
ag report "Auth module needs refactoring"
ag log-decision "Use PostgreSQL" "Team has deep expertise"No provider endpoint is configured in this package. When used from an AI IDE through MCP, the host main agent supplies LLM capability and may delegate refresh tasks to sub-agents.
MCP Integration (Consumer) 鈥?Let agents call external tools
MCPClientManager lets your agents connect to external MCP servers (GitHub, databases, etc.), auto-discovering and registering tools.
// mcp_servers.json
{
"servers": [
{
"name": "github",
"transport": "stdio",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"enabled": true
}
]
}Set MCP_ENABLED=true in .env.
GitNexus Graph Enrichment 鈥?Automatic structural intelligence for ask queries
GitNexus builds a code knowledge graph using Tree-sitter AST parsing (16 languages). When installed, Antigravity integrates it at two levels:
1. Refresh-time indexing 鈥?ag-refresh automatically runs gitnexus analyze (Step 9) to build/update the code graph. Skipped silently if GitNexus is not installed.
2. Ask-time graph enrichment 鈥?The Router LLM decides whether a question needs structural analysis:
- "What does the auth module do?" 鈫?
GRAPH: no鈫?pure agent.md answer - "Who calls handleLogin?" 鈫?
GRAPH: yes鈫?queries GitNexus 鈫?graph data + agent.md 鈫?enriched answer
User: "What functions call the send method in gateway?"
Router: MODULES: gateway, tests_gateway | GRAPH: yes
鈫?GitNexus query returns call chains with confidence scores
鈫?Agent docs provide semantic context (what each caller does)
鈫?Combined answer: precise call chain + file paths + line numbers + purpose
| Capability | What it provides |
|---|---|
gitnexus_query |
Hybrid search (BM25 + semantic) 鈥?execution flows, not just files |
gitnexus_context |
360-degree symbol view: callers, callees, references, definition |
gitnexus_impact |
Blast radius analysis 鈥?what breaks if you change a symbol? |
Note: GitNexus is NOT bundled with Antigravity. It requires separate installation via npm (
npm install -g gitnexus). Antigravity works fully without it 鈥?when not installed, all graph features are silently skipped with zero overhead.
How to enable:
# 1. Install GitNexus (requires Node.js)
npm install -g gitnexus
# 2. Refresh (auto-indexes the code graph)
ag-refresh --workspace my-project
# 3. Ask 鈥?graph enrichment is automatic
ag-ask "Who calls the send method in gateway adapters?"
# Router decides: GRAPH: yes 鈫?queries GitNexus 鈫?enriched answerSandbox 鈥?Configurable code execution environment
| Variable | Default | Options |
|---|---|---|
SANDBOX_TYPE |
local |
local 路 microsandbox |
SANDBOX_TIMEOUT_SEC |
30 |
seconds |
See Sandbox docs.
Tested against OpenClaw 鈥?the most popular open-source AI assistant (TypeScript + Swift + Kotlin, 12,133 files) 鈥?using MiniMax2.7 free API.
$ ag-refresh --workspace /path/to/openclaw
[1/3] Scanning project... 5000 files, 0.14s
[7/8] 鈻?Running 154 modules (concurrency=8)...
Auto-split: extensions/ 鈫?50+ sub-modules (slack, telegram, whatsapp, ...)
Auto-split: src/ 鈫?40+ sub-modules (agents, gateway, config, ...)
[8/8] module_registry 鉁?164 lines
Total time: 42m52s | 111 module docs | 1.5MB knowledge base
| Category | Question | Result | Quality |
|---|---|---|---|
| Basic understanding | "What is this project?" | Pass | 5/5 鈥?sponsors, platforms, features, structure |
| Tech stack | "Tech stack and frameworks?" | Timeout | 3/5 鈥?fallback gave language/framework data |
| Module deep-dive | "How does Telegram integration work?" | Pass | 5/5 鈥?file table + architecture diagram + types + constants |
| Module deep-dive | "Discord voice channels?" | Pass | 5/5 鈥?audio pipeline + code samples + design patterns |
| Module deep-dive | "WhatsApp integration?" | Pass | 5/5 鈥?auth flow + plugin architecture + dependencies |
| Hallucination test | "Does this support GraphQL?" | 413 | 0/5 鈥?request too large for free API |
| Architecture | "How does Gateway work?" | Timeout | 2/5 鈥?file list but no analysis |
| Chinese query | "鏀寔鍝簺AI妯″瀷锛? | Timeout | 1/5 鈥?cross-module, needs faster model |
| Skills system | "What is the skill system?" | Timeout | 2/5 鈥?listed skill files |
| Testing patterns | "Testing frameworks?" | Timeout | 2/5 鈥?listed vitest configs |
| Platform listing | "What messaging platforms?" | Crash | 0/5 鈥?413 error |
鉁?Module-level Q&A (5/5) 鈿狅笍 Cross-module questions 鉂?Free API limits
鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€ 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€ 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
Telegram: architecture diagram Gateway: timeout 413 on large context
Discord: audio pipeline + code Testing: timeout Rate limiting (429)
WhatsApp: auth + plugin system Tech stack: timeout
Each module has its own knowledge doc Needs faster model or higher timeout
| Dimension | Score | Notes |
|---|---|---|
| Basic Q&A | 9/10 | Project overview excellent |
| Module deep-dive | 10/10 | Telegram/Discord/WhatsApp 鈥?architecture diagrams, types, design patterns |
| Cross-module | 3/10 | Gateway, Testing, Skills 鈥?timeout with free API |
| Overall | 6.5/10 | Module Q&A: production-ready even on 12K-file projects. Cross-module: needs faster model. |
| Metric | OpenCMO (374 files) | OpenClaw (12K files) | Improvement |
|---|---|---|---|
| Refresh time | ~10 min | 43 min | Parallel + auto-split |
| Module docs | 9 | 111 | 12x |
| Knowledge base | 540KB | 1.5MB | 2.8x |
| Module Q&A quality | 7/10 | 10/10 | Auto-split = focused knowledge |
What changed: Large modules (extensions/ with 262 groups, src/ with 363 groups) are now auto-split into independent sub-modules. All modules run in parallel (8 concurrency). This reduced OpenClaw refresh from 5+ hours (never finished) to 43 minutes (completed).
# No LLM provider key/model settings are required.
# These optional knobs tune local scanning and context packaging for large repos.
AG_ASK_TIMEOUT_SECONDS=120
AG_REFRESH_AGENT_TIMEOUT_SECONDS=180
AG_MODULE_AGENT_TIMEOUT_SECONDS=300
AG_MAX_GROUP_CHARS=800000 # Hard char limit per group (prevents context overflow)No OpenAI-compatible provider settings are required for Antigravity itself; use whichever LLM provider your host AI agent already uses.
Earlier Eval: MiniMax2.7 on OpenCMO (374 files, 29K lines)
Tested end-to-end against the OpenCMO codebase (Python + React/TS, 374 files) using MiniMax2.7 via an OpenAI-compatible router.
| Category | Question | Result | Quality |
|---|---|---|---|
| Basic understanding | "What is this project?" | Pass | 5/5 鈥?accurate summary with tech details |
| Tech stack | "What tech stack and frameworks?" | Pass | 5/5 鈥?frontend + backend + libs listed |
| Module listing | "List all main modules" | Pass | 5/5 鈥?table format, accurate |
| API routing | "How does API routing work?" | Pass | 5/5 鈥?routes + endpoints + client code |
| Precise function | "get_model() in llm.py signature" | Pass | 5/5 鈥?100% accurate file, line, logic |
| Hallucination test | "Does this support GraphQL?" | Pass | 5/5 鈥?correctly said No with 4-point evidence |
| Chinese query | "绀惧尯鐩戞帶鏀寔鍝簺骞冲彴?" | Pass | 5/5 鈥?Chinese answer, platform style table |
| Database schema | "List all database tables" | Pass | 5/5 鈥?34 tables listed with source file |
| Approval workflow | "How does approval work?" | Pass | 5/5 鈥?full state machine with line numbers |
| Complex architecture | "How does multi-agent work?" (120s) | Pass | 5/5 鈥?20 agents listed, comm patterns |
| Dimension | Score | Notes |
|---|---|---|
| Basic Q&A | 9/10 | Project, tech stack, modules 鈥?excellent |
| Code location | 7/10 | Precise queries great; same-name files can confuse |
| Hallucination control | 9/10 | Won't fabricate; gives negative evidence |
| Multi-language | 9/10 | Chinese Q&A excellent |
| Overall | 7/10 | Daily code Q&A: production-ready. Complex analysis: tune timeout. |
Full evaluation report:
artifacts/plan_20260404_opencmo_ask_boundary_eval.md
| 馃嚞馃嚙 English | docs/en/ |
| 馃嚚馃嚦 涓枃 | docs/zh/ |
| 馃嚜馃嚫 Espa帽ol | docs/es/ |
Ideas are contributions too! Open an issue to report bugs, suggest features, or propose architecture.
 猸?Lling0000 Major Contributor 路 Creative suggestions 路 Project administrator 路 Project ideation & feedback |
 Alexander Daza Sandbox MVP 路 OpenSpec workflows 路 Technical analysis docs 路 PHILOSOPHY |
 Chen Yi First CLI prototype 路 753-line refactor 路 DummyClient extraction 路 Quick-start docs |
 Subham Sangwan Dynamic tool & context loading (#4) 路 Multi-agent swarm protocol (#3) |
 shuofengzhang Memory context window fix 路 MCP shutdown graceful handling (#28) |
 goodmorning10 Enhanced ag ask context loading 鈥?added CONTEXT.md, AGENTS.md, and memory/*.md as context sources (#29)
|
 Abhigyan Patwari GitNexus 鈥?code knowledge graph natively integrated into ag ask for symbol search, call graphs, and impact analysis
|
 BBear0115 Skill packaging & KG retrieval enhancements 路 Multi-language README sync (#30) |
 SunkenCost ag clean command 路 __main__ entry-point guard (#37)
|
 Aravindh Balaji Unified instruction surface around AGENTS.md (#41)
|
 xiaolai NLPM audit feedback 路 Skill frontmatter fixes 路 Dependency hygiene review (#51, #52, #53) |
MIT License. See LICENSE for details.