What is Lola? The Universal AI Context Package Manager

If you have been using AI coding assistants like Claude Code, Cursor, or Gemini CLI, you have probably come across the concept of skills, commands, and agent instructions. These are reusable markdown-based packages that give AI assistants procedural knowledge about how to perform specific tasks.

But here is the problem: every AI assistant has its own way of loading these skills. Claude Code reads from .claude/skills/ and .claude/commands/. Cursor uses .cursor/rules/. Gemini CLI reads from GEMINI.md. If you write a skill for one assistant, it does not work on another without manual porting.

This is where Lola comes in.

What is Lola?

Lola is an open-source, universal package manager for AI context. Think of it as DNF/YUM for AI skills: if a skill is the RPM package, Lola is the package manager that installs it to the right place for your AI assistant.

You write your skills and context modules once as portable packages, then install them to any supported AI assistant with a single command.

lola install my-module -a claude-code
lola install my-module -a cursor
lola install my-module -a gemini-cli

Same module, different assistants, one command.

Why Do We Need Lola?

The industry is shifting from prompt engineering to context engineering. Instead of crafting one-off prompts, developers are building reusable packages of instructions, workflows, and reference material that AI assistants can discover and follow.

The challenge is fragmentation. Each AI assistant expects context in a different format and location:

Without Lola, you would need to manually copy and adapt skills for each assistant. Lola abstracts this away: it knows where each assistant expects files and handles the translation automatically.

Key Concepts

Modules

A Lola module is a portable package of AI context. It can contain:

• Skills - auto-triggered instructions that activate when your request matches
• Commands - slash commands you invoke explicitly (e.g., /review-pr)
• Agents - specialized subagent definitions

Modules are stored in ~/.lola/modules/ (project scope copies them into .lola/modules/ inside the project; user scope installs to platform-appropriate user config directories).

Module Structure

A module uses auto-discovery, no manifest file is required:

my-module/
  skills/
    code-review/
      SKILL.md           # Skill definition with YAML frontmatter
      scripts/           # Supporting files
  commands/
    quick-commit.md      # Slash command
  agents/
    reviewer.md          # Subagent definition

Marketplaces

A marketplace is a curated catalog of modules, like a package registry. Instead of hunting for individual repositories, you register a marketplace and search or install modules from it.

# Add a marketplace
$ lola market add general \
    https://raw.githubusercontent.com/RedHatProductSecurity/lola-market/main/general-market.yml

# Search modules
$ lola search --mod workflow

Local registry (1 module)

  cloud_content
    4 skills, 0 commands, 0 agents

# Install directly from marketplace
$ lola install lola-manager -a claude-code

Organizations can host private marketplaces to distribute internal skills at scale.

Installation Scopes

Lola supports two scopes:

• Project scope (default) - installs to the current project directory. Skills are available only in that project.
• User scope (--scope user) - installs globally to your user configuration directories. Skills are available across all projects.

# Project scope (default)
lola install my-module -a claude-code

# User/global scope
lola install my-module -a claude-code --scope user

How Lola Works Behind the Scenes

When you run lola install, Lola converts your module’s skills and commands into each assistant’s native format:

• Claude Code and Cursor get a full copy of the skill content. Cursor rewrites relative file paths since it only copies the .mdc skill content rather than the whole skill directory.
• Gemini CLI and OpenCode don’t copy skills at all. Instead, Lola adds reference entries to GEMINI.md or AGENTS.md that point the assistant back to the original SKILL.md inside .lola/modules/.

The key idea: Lola is just an installer. It does not run at execution time. After installation, your AI assistant reads its own native config files directly, and Lola is out of the picture until you run an update.

Getting Started

Install Lola

# Using pip
pip install lola-ai

# Using uv (recommended)
uv tool install lola-ai

Add a Marketplace

# Official community marketplace
lola market add general https://raw.githubusercontent.com/RedHatProductSecurity/lola-market/main/general-market.yml

Add and Install a Module

# From a git repository
lola mod add https://github.com/user/my-skills.git
lola install my-skills -a claude-code

# Or directly from a marketplace
lola search --mod <query>
lola install <module-name> -a claude-code

Verify Installation

# List all installed modules
lola list

# In Claude Code, check available skills
# Type /skills in the Claude Code prompt

Essential Commands

Declarative Management with .lola-req

For teams, you can declare module dependencies in a .lola-req file at your project root:

python-tools>=1.0.0
https://github.com/user/module.git@main
https://github.com/org/repo.git@main#subdirectory=plugins/dev
https://github.com/user/repo.git#assistant=claude-code,cursor

Then sync with:

lola sync

This helps a team keep the same AI skills installed, version-controlled and auditable, without everyone manually copying files around.

Supported AI Assistants

Licensing and Governance

Lola is released under the Apache-2.0 license and is community-governed by its maintainers, with an official marketplace maintained separately at the lola-market repository.

What is Next?

In the next post, we will walk through a practical example: installing Ansible community AI skills from the ai-forge project using Lola, and see how it fits into an Ansible development workflow.

References

• Lola on GitHub
• Lola Documentation
• Lola Community Marketplace
• Manage AI context with Lola - Red Hat Developer
• ai-forge: Ansible Community AI skills