Looplia Core

Skills-first agentic workflow CLI — compose AI skills and workflows for any task.

Looplia Core is an agentic workflow platform powered by the Claude Agent SDK. It provides a skills-first architecture where workflows declare which skill to execute and provide natural language missions, letting Claude determine the best approach.

Current focus: Content writing workflows (summarization, idea generation, writing kit construction)

Vision: A universal CLI for AI-powered workflows — one tool, many domains, powered by composable skills.

v0.7.4 Architecture

┌─────────────────────────────────────────────────────────────────────────────┐
│  CLI Commands                                                               │
│  └─ looplia init     → Initialize workspace + install marketplace skills    │
│  └─ looplia run      → Execute workflow on content                          │
│  └─ looplia build    → Build workflow from natural language                 │
│  └─ looplia registry → Manage skill registry sources                        │
│  └─ looplia skill    → Install and manage individual skills                 │
│  └─ looplia config   → Manage user profile                                  │
└─────────────────────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│  Workflow-as-Markdown + Per-Step Orchestration                              │
│  • Workflow definitions (workflows/*.md with YAML frontmatter)              │
│  • Each step: skill: + mission: syntax                                      │
│  • One step → one skill-executor call → multiple skills execution           │
│  • Validation-driven completion (validation.json)                           │
└─────────────────────────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│  Two-Plugin Model + Skill Registry                                          │
│  ┌─────────────────────────────┬───────────────────────────────────────────┐│
│  │ looplia-core                │ looplia-writer                            ││
│  │ (Infrastructure)            │ (Domain)                                  ││
│  ├─────────────────────────────┼───────────────────────────────────────────┤│
│  │ • CLAUDE.md (entry point)   │ • workflows/writing-kit.md                ││
│  │ • commands/run.md, build.md │ • skills/media-reviewer/                  ││
│  │ • skills/workflow-executor/ │ • skills/idea-synthesis/                  ││
│  │ • skills/workflow-validator/│ • skills/writing-kit-assembler/           ││
│  │ • skills/registry-loader/   │ • user-profile.json                       ││
│  │ • hooks (TypeScript v0.7.4) │                                           ││
│  └─────────────────────────────┴───────────────────────────────────────────┘│
│  ┌─────────────────────────────────────────────────────────────────────────┐│
│  │ Skill Registry System (v0.7.0)                                          ││
│  │ • ~/.looplia/registry/skill-catalog.json (compiled from all sources)    ││
│  │ • ~/.looplia/plugins/ (third-party skills from marketplaces)            ││
│  │ • Default sources: Anthropic (42+ skills), ComposioHQ (29+ skills)      ││
│  └─────────────────────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────────────────────┘

Features

• Skills-First Architecture - Workflows declare skills + missions, not rigid agent definitions
• Skill Registry System - shadcn/ui-inspired registry for skill discovery and installation
• Selective Plugin Loading - Only load skills required by workflow (reduced context usage)
• Third-party Skills - Install community skills via git clone from marketplaces
• Marketplace Integration - 56+ skills installed by default (Anthropic + ComposioHQ)
• Per-Step Orchestration - One workflow step → one skill-executor call → multiple skills
• Workflow-as-Markdown - YAML frontmatter + markdown documentation
• Sandbox Isolation - Each run in sandbox/{id}/inputs/outputs/logs/
• Validation-Driven - Deterministic script-based output validation
• Two-Plugin Model - Separate infrastructure (core) from domain logic (writer)
• Streaming TUI - Real-time progress with tool execution display
• Smart Continuation - Resume workflows via --sandbox-id
• TypeScript - Full type safety with Zod schemas

Quick Start

# 1. Install dependencies
bun install

# 2. Build the project
bun run build

# 3. Initialize workspace (creates ~/.looplia/ with plugins)
bun run apps/cli/dist/index.js init --yes

# 4. Run a workflow
export ANTHROPIC_API_KEY=sk-ant-...
bun run apps/cli/dist/index.js run writing-kit --file ./examples/ai-healthcare.md

CLI Commands

Command	Description
looplia init	Initialize workspace + install marketplace skills (56+)
looplia run <workflow-id>	Execute workflow on content
looplia build [description]	Build workflow from natural language
looplia registry <subcommand>	Manage skill registry sources
looplia skill <subcommand>	Install and manage individual skills
looplia config	Manage user profile settings
looplia config provider	Configure model provider and presets

Run Command

Execute a workflow from ~/.looplia/workflows/ on provided content:

# Create new sandbox and run workflow
looplia run writing-kit --file ./article.md

# Resume existing sandbox
looplia run writing-kit --sandbox-id article-2025-12-18-abc123

# Options
looplia run <workflow-id> --file <path>       # New sandbox
looplia run <workflow-id> --sandbox-id <id>   # Resume sandbox
looplia run <workflow-id> --mock              # Mock mode (no API)
looplia run <workflow-id> --no-streaming      # Batch mode

Build Command

Create a workflow definition from natural language:

# Interactive mode
looplia build

# Direct mode
looplia build "analyze videos and create blog outlines"

# With explicit name
looplia build --name article-summary "summarize articles and extract key points"

The build command uses three skills in sequence:

1. registry-loader - Load compiled skill catalog (v0.7.0)
2. skill-capability-matcher - Match requirements to skills
3. workflow-schema-composer - Generate workflow YAML/Markdown with skills: field

Registry Command

Manage skill registry sources:

looplia registry init              # Initialize registry with official source
looplia registry add <url>         # Add GitHub registry source
looplia registry sync              # Compile skill catalog from all sources
looplia registry list              # List configured sources and stats
looplia registry remove <id>       # Remove a registry source

Skill Command

Install and manage individual skills:

looplia skill add <name>           # Install skill to workspace
looplia skill list                 # List installed skills
looplia skill list --available     # Show all available skills
looplia skill info <name>          # Show skill details
looplia skill remove <name>        # Remove skill from workspace
looplia skill update <name>        # Update third-party skill (git pull)

Config Command

Manage user profile for personalized content:

# Set topics of interest
looplia config topics "AI, productivity, writing"

# Set writing style
looplia config style --tone expert --word-count 1500 --voice first-person

# Show current profile
looplia config show

# Configure model provider (v0.6.6)
looplia config provider show                       # Display current config
looplia config provider preset ZENMUX_MINIMAX_M21  # Apply preset
looplia config provider set auth-token sk-ai-xxx   # Set API key
looplia config provider reset                      # Clear config

Workflow Schema

Workflows are markdown files with YAML frontmatter. Each step declares a skill: and mission: for Claude to execute. See Workflow Schema for the complete schema reference and examples.

Sandbox Architecture

Both run and build commands create isolated sandbox directories:

~/.looplia/sandbox/{sandbox-id}/
├── inputs/content.md      # (run only) Copied from --file
├── outputs/               # Generated artifacts
├── logs/                  # Session logs
└── validation.json        # Step completion tracking

Sandbox ID formats:

• Run: {slug}-{YYYY-MM-DD}-{random4chars} (e.g., my-article-2025-12-18-xk7m)
• Build: build-{YYYY-MM-DD}-{random4chars} (e.g., build-2026-01-12-a1b2)

Available Skills

After looplia init, 56+ skills are available from three sources:

Built-in: Infrastructure (looplia-core)

Skill	Purpose
workflow-executor	Execute looplia workflows, orchestrate steps
workflow-validator	Validate JSON artifacts against criteria
registry-loader	Load compiled skill catalog for build pipeline
skill-capability-matcher	Match requirements to skills
workflow-schema-composer	Generate workflow definitions with skills: field

Built-in: Domain (looplia-writer)

Skill	Purpose
media-reviewer	Deep content analysis, extract themes and quotes
content-documenter	Structure content into documentation format
idea-synthesis	Generate hooks, angles, and questions
writing-kit-assembler	Assemble final writing kit with outline
user-profile-reader	Read user preferences for personalization

Third-party: Marketplace Skills

Installed during looplia init from default sources:

Source	Skills	Examples
Anthropic	42+	xlsx, pdf, docx, pptx, frontend-design, algorithmic-art, mcp-builder
ComposioHQ	14+	brand-guidelines, slack-gif-creator, webapp-testing

Run looplia skill list --available to see all skills. Install additional skills with looplia skill add <name>.

Development

# Start development
bun run dev

# Run tests
bun test

# Type check
bun run check-types

# Link CLI globally
cd apps/cli && bun link
looplia --help

# Test with real API
env $(cat .env) looplia run writing-kit --file test.md

Development Mode

For contributors developing looplia from source without running init:

# Set environment variables
export LOOPLIA_DEV=true
export LOOPLIA_DEV_ROOT=~/looplia-core

# Run from any directory - plugins loaded directly from source
cd ~/my-project
looplia run writing-kit --file ./article.md

Environment Variables

Variable	Description
ANTHROPIC_API_KEY	Required for Claude API
CLAUDE_CODE_OAUTH_TOKEN	Alternative: OAuth token for subscription auth
ZENMUX_API_KEY	ZenMux proxy API key (auto-mapped to ANTHROPIC_API_KEY)
OPENROUTER_API_KEY	OpenRouter API key (auto-mapped to ANTHROPIC_AUTH_TOKEN)
OLLAMA_API_KEY	Ollama API key (optional, defaults to "ollama")
LOOPLIA_AGENT_MODEL_MAIN	Override main agent model
LOOPLIA_AGENT_MODEL_EXECUTOR	Override executor model
LOOPLIA_HOME	Override ~/.looplia path (testing/custom installs)
LOOPLIA_DEV	Enable development mode (load from source)
LOOPLIA_DEV_ROOT	Path to looplia-core repo (for dev mode)

Claude Code Subscription Authentication

To use your Claude Code subscription instead of direct API credits:

# 1. Apply a subscription preset
looplia config provider preset CLAUDE_CODE_SUBSCRIPTION_OPUS

# 2. Set CLAUDE_CODE_OAUTH_TOKEN environment variable
# On macOS, extract from Keychain:
export CLAUDE_CODE_OAUTH_TOKEN=$(security find-generic-password -s "Claude Code-credentials" -w | jq -r '.claudeAiOauth.accessToken')

# Or set directly if you have the token:
export CLAUDE_CODE_OAUTH_TOKEN=sk-ant-oat01-...

Available subscription presets:

• CLAUDE_CODE_SUBSCRIPTION_HAIKU - Uses Claude Haiku 4.5
• CLAUDE_CODE_SUBSCRIPTION_SONNET - Uses Claude Sonnet 4.5
• CLAUDE_CODE_SUBSCRIPTION_OPUS - Uses Claude Opus 4.5

Documentation

Document	Description
docs/README.md	Full documentation index
DESIGN-0.7.0.md	Skill Registry System design (archived)
GLOSSARY.md	Ubiquitous language reference
openspec/project.md	Project conventions (OpenSpec)
RELEASE_CHECKLIST.md	Development and release workflow

Version History

See CHANGELOG.md for detailed version history and release notes.

License

Elastic License 2.0