How to build an AGY WIKI OKF on the Antigravity CLI
▲ 152 r/AGYSkills+24 crossposts

How to build an AGY WIKI OKF on the Antigravity CLI

AGY Builders,

We are all trying to build useful and scalable workflows for our AGY CLI and ecosystem, but the speed at which we need to learn, build, and deploy new things is incredibly overwhelming. If you are feeling that pressure, you are in the right place here at r/GoogleAntigravityCLI.

Over the past few weeks, I have been testing an "AGY WIKI OKF" setup that I put together myself (after inviting some members of this community to collaborate; mod is not proud). I know some folks might hesitate to trust a tutorial from a random Redditor, but I wanted to share this with the community anyway because it actually works.

I was able to build this because I am all-in on Google and the Antigravity Ecosystem. I’m a truly AGY—I am not some ultra-smart, 10x developer, but I know how to work hard, I dig for the right information, and I iterate.

AGY WIKI OKF | The Idea

To build a frictionless, token-efficient knowledge WIKI engine that transforms static documentation or notes (information) into an active, intelligent collaborator—orchestrated entirely by Antigravity CLI.

The core philosophy is simple: treat knowledge management as a clean pipeline and tokens as a premium, finite resource.

By anchoring this architecture to Google’s Antigravity CLI, the AGY WIKI OKF bypasses heavy middleware and complex UI layers, delivering a hyper-focused AI partner built entirely for execution speed, context hygiene, and minimal footprint.

Why adopting AGY WIKI OKF matters:

  • Stay organized (AGY OCD): Structured Markdown and YAML keep the chaos in check.
  • Save tokens: Doing more with less context window bloat.
  • Scale shareable knowledge: Making it easy to pass context and logic between different LLMs.
  • Humans and Agents working together: One standardized, readable format that works perfectly for both of us.
  • BYOD (Bring Your Own Data): Own your context. Port it to the newest model, platform, or OS instantly.

The Tools

The WIKI

In the agent-first era, a WIKI is no longer just a static graveyard for human notes; it is the operational hard drive for your agents. By maintaining a highly structured WIKI, you ensure that every piece of context is stored in a clean, machine-readable format. This means that whether you are testing a new modular skill or spinning up a specialized agent, your AGY CLI knows exactly where to find the precise context it needs to generate autonomous action, moving you far beyond simple, reactive conversational text.

Reference: Gist on Knowledge Representation

Google Open Knowledge Format (OKF)

Google’s Open Knowledge Format (OKF) feels like the exact missing piece we've needed for orchestrating multiple AI agents effectively. It provides a vendor-neutral, interoperable standard for storing and sharing organizational knowledge.

Why this is huge for orchestration:

  1. The "Lingua Franca" for Agents: Any agent can read it out of the box without platform-specific integrations.
  2. Seamless Context Passing: Specialized agents can access, update, and pass the exact same foundational context back and forth.
  3. Human-in-the-Loop Oversight: Because OKF is just Markdown and YAML, it’s inherently readable and auditable.
  4. Scalable Knowledge: It acts as a shared, living library that grows alongside your agents.

AGY WIKI OKF Integration

Structuring an AGY Wiki using OKF revolutionizes how complex knowledge is shared. By standardizing documentation with concise Markdown and YAML frontmatter, OKF provides a unified taxonomy for cataloging AGY CLI slash commands or skills It is highly token-efficient, stripping away bloated formatting and maximizing context window limits.

The Prompt for Building an AGY WIKI OKF

AGY CLI WIKI OKF PROMT EXAMPLE

/grillme I want to initialize a brand-new, empty Obsidian vault from scratch that adheres strictly to the Open Knowledge Format (OKF) standard, with the specific intent of potentially open-sourcing or sharing this architecture later. I want a purely blank, skeletal framework with no pre-populated data. Please grill me to define the optimal architectural blueprint for this vault. I need you to interrogate me on: Do not generate the directory structure or files until you are satisfied that you have captured all my requirements for a production-ready, shareable knowledge base. 
Core Directory Hierarchy: How should we structure the root (e.g., /concepts, /resources, /indices, /log) to be intuitive for external users? Template Strategy: What base boilerplate templates do we need to ensure every new file is automatically OKF-compliant and structured for consistent metadata? Workflow Logic: Since this is a fresh start, what processes should we bake in for capturing information vs. refining knowledge that could be easily documented for others? CLI Integration: What specific file locations or configurations do we need to ensure this vault plays nicely with the Antigravity CLI from day one? Open-Source & Contributor Documentation: What files should we create to make this a "deployable" standard? Please include requirements for: A README.md with installation and usage instructions. A CONTRIBUTING.md that defines how to add new concepts or schemas. A "System Architecture" document that explains the logic behind the folder structure and metadata fields, ensuring anyone who clones this vault understands how to extend it.

The Final File Structure

AGY WIKI OKF
    ├── .agyrc
    ├── ARCHITECTURE.md
    ├── CONTRIBUTING.md
    ├── README.md
    ├── .agy
    │   └── .keep
    ├── .obsidian
    │   ├── app.json
    │   ├── appearance.json
    │   ├── core-plugins.json
    │   └── workspace.json
    ├── 00-Inbox
    │   └── .keep
    ├── 10-Projects
    │   └── .keep
    ├── 20-Areas
    │   └── .keep
    ├── 30-Resources
    │   ├── .keep
    │   └── Google Antigravity Documentation.md
    ├── 40-Archive
    │   └── .keep
    ├── 99-Meta
    │   └── Templates
    │       ├── Base_Template.md
    │       ├── Project_Template.md
    │       └── Resource_Template.md
    └── Clippings

TL;DR

  • AGY WIKI OKF: Organizes your information (context) , AGY CLI commands, skills  behaviors, and A2A workflows into a token-efficient, shareable format that reduces inference costs for any LLM.
  • Open Knowledge Format (OKF): Provides a standardized, vendor-neutral way to share context (Markdown + YAML), preventing platform lock-in and eliminating data fragmentation.

AGY Builders, I genuinely want your input on this. Please comment, grill me, roast me, ask questions, or give me your raw feedback on this AGY WIKI OKF setup. We are building the foundation to organize and share our data in the BYOD era. Let's build the future together.

u/AgentPadrino — 3 days ago

How to build an AGY WIKI OKF on the Antigravity CLI | Stay organized and save tokens

AGY Builders,

We are all trying to build useful and scalable workflows for our AGY CLI and ecosystem, but the speed at which we need to learn, build, and deploy new things is incredibly overwhelming. If you are feeling that pressure, you are in the right place here at r/GoogleAntigravityCLI.

Over the past few weeks, I have been testing an "AGY WIKI OKF" setup that I put together myself (after inviting some members of this community to collaborate; mod is not proud). I know some folks might hesitate to trust a tutorial from a random Redditor, but I wanted to share this with the community anyway because it actually works.

I was able to build this because I am all-in on Google and the Antigravity Ecosystem. I’m a truly AGY—I am not some ultra-smart, 10x developer, but I know how to work hard, I dig for the right information, and I iterate.

AGY WIKI OKF | The Idea

To build a frictionless, token-efficient knowledge WIKI engine that transforms static documentation or notes (information) into an active, intelligent collaborator—orchestrated entirely by Antigravity CLI.

The core philosophy is simple: treat knowledge management as a clean pipeline and tokens as a premium, finite resource.

By anchoring this architecture to Google’s Antigravity CLI, the AGY WIKI OKF bypasses heavy middleware and complex UI layers, delivering a hyper-focused AI partner built entirely for execution speed, context hygiene, and minimal footprint.

Why adopting AGY WIKI OKF matters:

  • Stay organized (AGY OCD): Structured Markdown and YAML keep the chaos in check.
  • Save tokens: Doing more with less context window bloat.
  • Scale shareable knowledge: Making it easy to pass context and logic between different LLMs.
  • Humans and Agents working together: One standardized, readable format that works perfectly for both of us.
  • BYOD (Bring Your Own Data): Own your context. Port it to the newest model, platform, or OS instantly.

The Tools

The WIKI

In the agent-first era, a WIKI is no longer just a static graveyard for human notes; it is the operational hard drive for your agents. By maintaining a highly structured WIKI, you ensure that every piece of context is stored in a clean, machine-readable format. This means that whether you are testing a new modular skill or spinning up a specialized agent, your AGY CLI knows exactly where to find the precise context it needs to generate autonomous action, moving you far beyond simple, reactive conversational text.

Reference: Gist on Knowledge Representation

Google Open Knowledge Format (OKF)

Google’s Open Knowledge Format (OKF) feels like the exact missing piece we've needed for orchestrating multiple AI agents effectively. It provides a vendor-neutral, interoperable standard for storing and sharing organizational knowledge.

Why this is huge for orchestration:

  1. The "Lingua Franca" for Agents: Any agent can read it out of the box without platform-specific integrations.
  2. Seamless Context Passing: Specialized agents can access, update, and pass the exact same foundational context back and forth.
  3. Human-in-the-Loop Oversight: Because OKF is just Markdown and YAML, it’s inherently readable and auditable.
  4. Scalable Knowledge: It acts as a shared, living library that grows alongside your agents.

AGY WIKI OKF Integration

Structuring an AGY Wiki using OKF revolutionizes how complex knowledge is shared. By standardizing documentation with concise Markdown and YAML frontmatter, OKF provides a unified taxonomy for cataloging AGY CLI slash commands, SKILLS.md behaviors, and Agent-to-Agent (A2A) workflows or context in general

. It is highly token-efficient, stripping away bloated formatting and maximizing context window limits.

The Prompt for Building an AGY WIKI OKF

AGY CLI WIKI OKF PROMT EXAMPLE

/grillme I want to initialize a brand-new, empty Obsidian vault from scratch that adheres strictly to the Open Knowledge Format (OKF) standard, with the specific intent of potentially open-sourcing or sharing this architecture later. I want a purely blank, skeletal framework with no pre-populated data. Please grill me to define the optimal architectural blueprint for this vault. I need you to interrogate me on: Do not generate the directory structure or files until you are satisfied that you have captured all my requirements for a production-ready, shareable knowledge base. 
Core Directory Hierarchy: How should we structure the root (e.g., /concepts, /resources, /indices, /log) to be intuitive for external users? Template Strategy: What base boilerplate templates do we need to ensure every new file is automatically OKF-compliant and structured for consistent metadata? Workflow Logic: Since this is a fresh start, what processes should we bake in for capturing information vs. refining knowledge that could be easily documented for others? CLI Integration: What specific file locations or configurations do we need to ensure this vault plays nicely with the Antigravity CLI from day one? Open-Source & Contributor Documentation: What files should we create to make this a "deployable" standard? Please include requirements for: A README.md with installation and usage instructions. A CONTRIBUTING.md that defines how to add new concepts or schemas. A "System Architecture" document that explains the logic behind the folder structure and metadata fields, ensuring anyone who clones this vault understands how to extend it.

The Final File Structure

AGY WIKI OKF
    ├── .agyrc
    ├── ARCHITECTURE.md
    ├── CONTRIBUTING.md
    ├── README.md
    ├── .agy
    │   └── .keep
    ├── .obsidian
    │   ├── app.json
    │   ├── appearance.json
    │   ├── core-plugins.json
    │   └── workspace.json
    ├── 00-Inbox
    │   └── .keep
    ├── 10-Projects
    │   └── .keep
    ├── 20-Areas
    │   └── .keep
    ├── 30-Resources
    │   ├── .keep
    │   └── Google Antigravity Documentation.md
    ├── 40-Archive
    │   └── .keep
    ├── 99-Meta
    │   └── Templates
    │       ├── Base_Template.md
    │       ├── Project_Template.md
    │       └── Resource_Template.md
    └── Clippings

AGY CLI WIKI OKF PARA FILE STRUCTURE

Obsidian screenshot using OKF for knowledge context in Antigravity CLI

TL;DR

  • AGY WIKI OKF: Organizes your information (context) , AGY CLI commands, SKILLS.md behaviors, and A2A workflows into a token-efficient, shareable format that reduces inference costs for any LLM.
  • Open Knowledge Format (OKF): Provides a standardized, vendor-neutral way to share context (Markdown + YAML), preventing platform lock-in and eliminating data fragmentation.

AGY Builders, I genuinely want your input on this. Please comment, grill me, roast me, ask questions, or give me your raw feedback on this AGY WIKI OKF setup. We are building the foundation to organize and share our data in the BYOD era. Let's build the future together.

reddit.com
u/AgentPadrino — 7 days ago
▲ 11 r/GoogleAntigravityCLI+1 crossposts

Announcing r/AGYSkills to Power Your Autonomous Agents 🧠

AGY Builders,

As our community continues to grow, it’s amazing to see how we are pushing the boundaries of what the Antigravity CLI can do. To better organize our progress, we are officially splitting our focus into two distinct pillars: Infrastructure and Architecture.

To give both sides the dedicated space they deserve, we are launching a sister subreddit: r/AGYSkills.

🏛️ r/GoogleAntigravityCLI: The Infrastructure

The definitive home for how the tool runs.

Keep coming here for core technical discussions:

  • Environment Setup: Terminal configurations and platform-specific setups.
  • CLI Essentials: Command syntax, flag documentation, and version updates.
  • Technical Deep-Dives: Authentication, environment variables, and advanced troubleshooting.

🧠 r/AGYSkills: The Architecture

The sandbox for what the tool can execute autonomously.

"Skills" are the modular logic that turns the CLI into an autonomous powerhouse. Head over to the new sub for:

  • Prompt Engineering: Optimizing system prompts and execution logic.
  • Workflow Design: Structuring YAML frontmatter and execution scripts.
  • Community Library: Sharing, trading, and refining modular code blocks for specific tasks.

Why the split?

We want to keep r/GoogleAntigravityCLI laser-focused on stable infrastructure without burying core technical documentation under prompt scripts—and vice versa.

  • Need your environment firing on all cylinders? r/GoogleAntigravityCLI
  • Need to build or borrow autonomous workflows? r/AGYSkills

The doors are officially open on June 18 at 00:01 CST Head over, hit subscribe, and let’s start building the modular future of autonomous agents together!

See you there,

u/AgentPadrino — The Mod Team

r/GoogleAntigravityCLI & r/AGYSkills

reddit.com
u/AgentPadrino — 3 days ago

Intro to Agent Skills

How "Agent Skills" can level up your AI-driven dev workflow (Video Summary)

Hey folks! I just watched this quick intro on Agent Skills by Google Antigravity, and it’s super useful for anyone building with AI coding agents or dealing with context window limits.

Here’s a summary of the video: Intro to Agent Skills.

TL;DR: As we move to agent-driven code chats, putting your whole codebase into the prompt causes "context bloat." Agent Skills fix this by letting agents lazily load specific instructions, frameworks, or code snippets only when they actually need them.

🧠 The Core Problem: Context Bloat

  • We’re moving from simple code completion to full agentic-driven chats. But trying to fit an entire codebase into an AI's context window leads to wasted tokens and confused models.

🛠️ The Solution: Agent Skills

  • "Skills" provide narrow, deep context. Instead of loading everything at once, the AI discovers and "lazily loads" these skills only when they are relevant to the current task.
  • What is a skill? It’s literally just a skill.md file in a specific directory (either a global agent skills folder or local to your project).
  • You use simple YAML front matter to define the name and description. The agent reads this front matter to quickly decide if the skill makes sense for its current job before reading the whole file.
  • You can make them global (for general frameworks/languages) or project-specific (for custom backends or specific app libraries). You can also collocate scripts, code examples, and other assets right next to them.

🏗️ How to Build & Use Custom Skills

  • To make one, you simply set up a nested folder like .agent/skills/html3dcanvas and add your skill.md.
  • You don't even have to write them yourself—you can just ask your AI agent (Gemini) to generate the skill file for you. For example, you can generate a skill for working with newer tech like Three.js's new Tiny Shader Language (TSL) which might not be well represented in the model's baseline training data.
  • Why this matters: When you ask an agent to build something, it creates a plan and loads these skills into context on the fly. It helps guarantee the agent follows your specific company/industry standards and the exact coding style you are going for.

🤝 Sharing & Open Standards

  • Because skills are just files saved alongside your project, sharing the project means the skills go with it—distributing that knowledge automatically to the rest of your team.

Hope this summary is helpful for anyone looking into optimizing their AI Agentic workflows!

youtube.com
u/AgentPadrino — 16 days ago

Why Google is betting everything on the "Agent-First Era" (and why they are right)

**AGY Builders:

We’ve officially outgrown the "Chatbot" phase. Why Google is betting everything on the "Agent-First Era" (and why they are right). If you step back and look at how we actually use AI right now, it’s mostly as a hyper-competent oracle. You type a prompt, it spits out an answer. You ask for a block of code, it writes it. It’s incredibly powerful, but it’s still fundamentally a "pull" mechanism. You have to drive the interaction every single step of the way.

But behind the scenes, the entire industry is pivoting away from conversational bots toward AI Agents. Google has been explicitly calling this the "agent-first era," and it represents the most significant paradigm shift since the release of ChatGPT.

Here is a breakdown of why chatbots were just the tech demo, and why agents are the actual product.

The Brain in a Jar vs. The Brain with Hands

To understand why this is a massive deal, we need to separate an LLM from an Agent:

An LLM is a brain in a jar. It knows a lot, but it can only talk to you through the glass.

An Agent is that same brain, but given a body, hands, a credit card, and a to-do list!

Agents don't just generate text; they generate actions. They use the LLM as their core reasoning engine to perceive an environment, make a plan, use external tools (like APIs, web browsers, or software interfaces), execute the plan, and—crucially—check their own work to see if they succeeded.

When you ask a chatbot to plan a vacation, it gives you a bulleted itinerary. When you ask an agent to plan a vacation, it checks your calendar for free dates, cross-references flight prices, books the tickets using your payment info, blocks out the time in your schedule, and drafts a message to your boss asking for the PTO.

Why Google Called It the "Agent-First Era"

Google’s leadership started hammering the phrase "agent-first" because they realize that pure text generation is becoming commoditized. The real moat isn't just having the smartest model; it’s having a model that can do things across an entire ecosystem.

The Ecosystem Advantage: Google owns Android, Chrome, Workspace (Docs, Gmail, Drive), and Search. An agent is only as good as the tools it can access. Google doesn't need to build clunky third-party integrations; they can bake agentic workflows directly into the OS level.

Multimodality & Project Astra: True agents need to see and hear the real world in real-time. Google’s push with projects like Astra showed models that can process live video feeds, remember where you left your keys, and interact with the physical world through your phone's camera.

Moving from Zero-Sum to Automation: Right now, AI makes you 30% faster at your job. But an agent does the job for you while you do something else. Google sees a future where you don't just ask Gemini a question; you give it a complex, multi-day objective and let it run autonomously in the background.

The Secret Sauce: Agent "Skills"

If you’re wondering how an agent actually knows how to do your specific job without hallucinating, the answer lies in something the industry is calling Agent Skills.

In this new architecture, a "skill" isn't an abstract concept—it is a literal, plug-and-play folder of instructions (usually anchored by a SKILL.md file) that you can hand directly to an agent. It contains your company’s standard operating procedures, API documentation, templates, and even executable scripts.

Instead of writing a massive, 2,000-word prompt every single time you want the AI to do something, you simply equip the agent with a "skill." When it encounters a problem, it automatically searches its library, loads only the specific skill required for that exact moment, executes the task perfectly according to your rules, and unloads it.

This is the ultimate game-changer because it transforms agents from generic assistants into hyper-specialized workers. It solves the biggest bottleneck in AI right now: context limits and repetitive prompting. Both Google and the broader open-source community are heavily backing this modular standard.

It means that soon, we won't just be sharing prompts; we will be sharing entire open-source "Skills" that immediately teach anyone's personal agent how to flawlessly execute a complex financial audit, edit a video, or deploy a server architecture. It’s the digital equivalent of instantly downloading specialized expertise directly into your AI's brain.

What This Means for the Future

The "chatbot era" taught us how to talk to machines in natural language. The "agent-first era" will teach machines how to navigate our digital world.

We are moving toward a future where everyone has a fleet of digital employees. You will have a research agent, a scheduling agent, a financial agent, and a coding agent. Your personal agent will negotiate with a customer service agent from an airline to get your flight refunded. The internet will transition from a place where humans consume data, to an environment where human-owned agents interact with corporate-owned agents.

Google calling it the "agent-first era" wasn't just marketing speak. It was a declaration of war for the next decade of computing. The interface of the future isn't a text box; it's a delegate button.

TL;DR: Chatbots are just "brains in a jar" that output text. AI Agents are systems that use an AI brain to make plans, use tools, and take real-world actions on your behalf. Google declared the "agent-first era" because the future of AI isn't just smarter text generators—it’s autonomous digital workers that operate across Android, Workspace, and the web to complete multi-step tasks. By using standardized "Skills," these agents can now load specific instructions and scripts on-demand, making them hyper-specialized and reliable. The interface of the future is delegation, not typing!

For a complete breakdown of how these technologies look in practice, you can check out this  :

which details the exact agent features, Search tools, and system updates Google announced for this new architecture.

Tags: AI Agents | Agent-First Era | Google Ecosystem | Project Astra | Agent Skills | AGY Skills | Antigravity | Tech Automation |

u/AgentPadrino — 16 days ago
▲ 5 r/AGYSkills+2 crossposts

Welcome to r/AGYSkills: The Home for AGY Builders Skills in the Agents-First Era!

Welcome to your Skills hub for Antigravity. If you are building, tinkering, or designing custom AI agent behaviors, you have found your community.

r/AGYSkills is designed specifically for the creators and engineers pushing the boundaries of what autonomous agents can do. The "agents-first" era is here, and this is a collaborative hub for sharing and learning everything related to AGY skills, architectures, and workflows.

Why Skills Are the Core of Antigravity

In the Antigravity ecosystem (including r/GoogleAntigravityCLI, r/GoogleAntigravityIDE, or r/Google_Antigravity), an agent without skills is essentially just a passive chat interface.

Skills are what transform static models into autonomous operators. They represent the modular capabilities, toolsets, and discrete behaviors that allow agents to interact with systems, execute tasks, and make decisions.

Why do skills matter so much right now?

  • The Shift to Composability: Instead of building massive, monolithic applications, the focus is now on engineering discrete, reusable skills that agents can dynamically call upon.
  • Unlocking True Autonomy: Skills bridge the gap between a model's internal reasoning and real-world execution—whether that means interacting with local system environments, handling data pipelines, or utilizing external APIs.
  • The Foundation of A2A: For complex Agent-to-Agent orchestration to succeed, agents must be able to understand what other sub-agents are capable of. Clearly defined skills act as the "API contract" between agents, allowing them to collaborate and hand off tasks seamlessly.

What Are We Building?

This space is dedicated to the technical side of the ecosystem. We want to see your work, whether you are:

  • AGY Focus Skills: Building skills that align with our antigravity workflows.
  • Exploring A2A: Crafting complex, multi-step Agent-to-Agent architectures that rely on skill hand-offs.
  • Integrating MCP: Building tools and seamless workflows utilizing the Model Context Protocol to expand an agent's technical skill set.
  • Pushing Open-Source: Dropping shell scripts, custom terminal configurations, and open-source agent behaviors. AGY community skills will be open-sourced from the AGY builders community to the wider AI Agent community.

What You Should Post

  • Show and Tell: Got a new sub-agent skill working smoothly? Show us the repo, drop a terminal cast, and explain how you built it.
  • Tutorials & Workflows: Share your step-by-step guides on optimizing agentic workflows and behavior design.
  • Architecture Discussions: Let's debate the best ways to structure, scale, and register skills in multi-agent systems.
  • Troubleshooting: Hit a wall with tool integration or behavior loops? Share your logs and let the community help you debug.

The Community Vibe

Keep it collaborative and open. We are all navigating this new frontier of AI development together. Share your successes, but also do not be afraid to post your broken code—that is exactly how we learn.

To kick things off, introduce yourself in the comments! What specific skills or autonomous behaviors are you currently building?

Let's build the future, one agent at a time (with multi-agent orchestration in the background).

reddit.com
u/AgentPadrino — 14 days ago
▲ 20 r/AGYSkills+4 crossposts

The Ultimate AGY CLI Anki Deck for Commands Let's Crowdsource 🧠

Hey AGY CLI Builders, let's build the future together.

Spending the weekend reading theofficial AGY Documentationis fine, but for us, keeping our fingers on the terminal is what actually matters. Having instant muscle memory for our day-to-day commands is critical for a fast, uninterrupted workflow. That is why we are building The Ultimate AGY CLI Anki Deck, crowdsourced directly from the knowledge in this community.

🛠️ The Goal

Create community-driven definitions, practical examples, and best use cases for every core command in the AGY CLI.

📋 How It Works

Below is a list of the core AGY commands organized by category.

  • Pick a command and reply to the command comments on this thread with how you actually use it in the wild.
  • Share your secrets: Give us your best flags, real-world edge cases, chained workflows, or "gotchas" to watch out for.

Once every command has a solid explanation, I will compile the highest-voted replies, convert them into a master Anki deck, and drop the file back here for everyone to download for free.

1️⃣ Session & Conversation Control

  • /branch (alias for /fork)
  • /btw <query>
  • /clear
  • /conversation (alias for /resume)
  • /exit
  • /fork
  • /logout
  • /rename <name>
  • /resume
  • /rewind
  • /switch (alias for /resume)
  • /undo (alias for /rewind)

2️⃣ Environment & Configuration

  • /config
  • /fast
  • /keybindings
  • /model
  • /permissions
  • /planning
  • /settings (alias for /config)
  • /statusline
  • /title [on/off]

3️⃣ Code, Tools & Background Tasks

  • /add-dir <path>
  • /agents
  • /diff
  • /hooks
  • /mcp
  • /open <path>
  • /skills
  • /tasks
  • /usage

Drop your best command workflows in the comments below. Which command are you claiming? 👇

u/AgentPadrino — 16 days ago

We try, we learn, we try harder then we wait !!!

Maybe someday the situation will improve.... :( see you in 109 hrs... basically the free account is unusable

u/AgentPadrino — 26 days ago