Skip to content
Regolo Logo
Regolo Logo

Using MiniMax skills with Regolo.ai: a practical guide

Curated byAlex Genovese·Fresh as of

We can treat MiniMax “skills” as reusable, high-level instruction blocks or toolkits that specialize an AI agent for tasks like frontend dev, PDF/XLSX processing, or multimodal work. With Regolo.ai, we can call an open-source model via OpenAI‑compatible APIs and benchmark how different skills affect quality, latency, and cost for the same prompts.

Below we walk through what MiniMax skills are, how to install and reference them, and how to build a simple Python harness using Regolo.ai to select skills and run benchmarks from the command line.

What we will build

We will build a small Python CLI that:

  1. Lets us pick one or more MiniMax skills (e.g. frontend-dev, minimax-pdf, minimax-xlsx).
  2. Sends the selected skill description into the system prompt of a Regolo.ai model.
  3. Runs a fixed set of benchmark tasks (e.g. “build a React component”, “describe a PDF transformation”) and records:
    • response content,
    • latency,
    • token usage (approximate),
      so we can compare different skills.

We assume skills are available as local SKILL.md files (exported from the MiniMax skills repo or agent marketplace) and that Regolo.ai is used strictly for inference, not as the skills host.

What are MiniMax skills?

MiniMax skills are curated, production-grade instruction packs and tool definitions designed to make AI coding agents perform consistently on real tasks. They encode step‑by‑step workflows, quality bars, and sometimes integration hints for tools like PDFs, spreadsheets, or multimodal APIs.

Some examples from the MiniMax ecosystem include:

  • frontend-dev: for high‑quality UI/UX, animations, and full‑stack frontend work.
  • minimax-pdf: for creating and transforming PDFs with professional formatting.
  • minimax-xlsx: for advanced spreadsheet work and data analysis.

In agent platforms like Claude Code or Cursor, these skills are discovered via a skills configuration that points to the skill folder and sets environment variables such as MINIMAX_API_HOST and MINIMAX_API_KEY. In our case, we will “consume” the skill text directly in the prompt and call a Regolo.ai model for responses.

How MiniMax skills are typically loaded

In MiniMax‑based agents or Claude Code, a skill is usually installed by:

  1. Downloading or cloning the MiniMax skills repository.
  2. Placing a SKILL.md file under a dedicated directory, for example:
    .claude/skills/minimax-multimodal-toolkit/SKILL.md.
  3. Declaring it in the agent’s config, e.g. in JSON/YAML:
    • an entry like "minimax-multimodal-toolkit" under skills.entries,
    • environment variables (MINIMAX_API_HOST, MINIMAX_API_KEY) if the skill talks to MiniMax APIs.

Then the agent auto‑discovers the skill and loads its instructions into the system prompt or tool registry.

For our benchmarking harness, we simplify: we will just read the SKILL.md content and prepend it to the system message when calling Regolo.ai.

Step-by-step: benchmarking MiniMax skills on Regolo.ai

We will assume a directory like:

skills/
  frontend-dev/
    SKILL.md
  minimax-pdf/
    SKILL.md
  minimax-xlsx/
    SKILL.md

Each SKILL.md is pulled from the official MiniMax skills repository or associated hubs (e.g. GitHub or skill marketplaces).

1. Define benchmark tasks

Start with a small list of textual tasks that reflect what the skill is meant to do. For example, for frontend-dev:

  • “Given this feature description, propose a React component API and JSX skeleton.”
  • “Refactor this CSS to Tailwind with better responsiveness.”

We will hardcode a small list in Python so that each run is reproducible.

2. Load skills from disk

We will implement a helper that:

  • lists subdirectories under skills/,
  • treats each directory name as skill_id,
  • reads SKILL.md and returns its text.

This lets us select skills interactively.

3. Build a simple CLI selector

We will print available skills, ask the user to pick one or more via input (e.g. “1,3”), and then run all benchmarks for each selected skill. If you prefer, you can pass skill names via command‑line arguments.

4. Call Regolo.ai with skill applied in the system prompt

For each benchmark, we will call a Regolo.ai chat completion endpoint using an OpenAI‑compatible client. The pattern is:

  • System message:
    • generic guidelines (“You are an expert [domain] assistant…”)
    • plus the raw SKILL.md content.
  • User message: the benchmark task.

We will measure latency with a simple timestamp difference around the request.

5. Collect metrics

For each (skill, task) pair we will store:

  • skill id,
  • task id and text,
  • response text,
  • duration in seconds,
  • token estimates (if the client exposes it; otherwise we can approximate or leave as None).

At the end we can print a table or write a CSV.

Code example

Below is a self‑contained script that:

  • discovers skills under skills/,
  • lets us choose skills interactively,
  • runs a simple benchmark set,
  • calls Regolo.ai using an OpenAI‑compatible pattern, as shown in Regolo’s docs.

Replace:

  • YOUR_REGOLO_API_KEY with your real key from account,
  • MODEL_ID_PLACEHOLDER with a valid Regolo model id from the latest documentation.
import os
import time
import json
from typing import List, Dict

from openai import OpenAI

REGOLO_API_KEY = "YOUR_REGOLO_API_KEY"
REGOLO_BASE_URL = "https://api.regolo.ai/v1"
REGOLO_MODEL_ID = "MODEL_ID_PLACEHOLDER"  # e.g. from Regolo docs

SKILLS_ROOT = "skills"

client = OpenAI(
    api_key=REGOLO_API_KEY,
    base_url=REGOLO_BASE_URL,
)


def list_skills() -> Dict[int, str]:
    entries = []
    for name in sorted(os.listdir(SKILLS_ROOT)):
        full = os.path.join(SKILLS_ROOT, name)
        if os.path.isdir(full) and os.path.isfile(os.path.join(full, "SKILL.md")):
            entries.append(name)

    indexed = {i + 1: entries[i] for i in range(len(entries))}
    print("Available skills:")
    for idx, name in indexed.items():
        print(f"  [{idx}] {name}")
    return indexed


def load_skill_text(skill_name: str) -> str:
    path = os.path.join(SKILLS_ROOT, skill_name, "SKILL.md")
    with open(path, "r", encoding="utf-8") as f:
        return f.read()


def select_skills(indexed: Dict[int, str]) -> List[str]:
    raw = input("Select skills by index (comma-separated, e.g. 1,3): ").strip()
    if not raw:
        return []
    chosen = []
    for piece in raw.split(","):
        piece = piece.strip()
        if not piece:
            continue
        idx = int(piece)
        if idx in indexed:
            chosen.append(indexed[idx])
    return chosen


BENCHMARK_TASKS = [
    {
        "id": "task-frontend-1",
        "description": "Design a React component API and JSX skeleton for a responsive pricing table with three tiers, including hover states and CTA buttons."
    },
    {
        "id": "task-frontend-2",
        "description": "Refactor the following CSS into Tailwind classes and explain the responsive behavior clearly:\n\n.main-card { padding: 24px; max-width: 640px; margin: 0 auto; box-shadow: ... }"
    },
]


def run_single_completion(skill_name: str, skill_text: str, task: Dict) -> Dict:
    system_instructions = f"""
You are an expert coding assistant.

You MUST follow the following SKILL definition exactly to perform your work.
The SKILL describes expectations, workflows, and quality criteria.

--- BEGIN SKILL {skill_name} ---
{skill_text}
--- END SKILL {skill_name} ---
""".strip()

    messages = [
        {"role": "system", "content": system_instructions},
        {"role": "user", "content": task["description"]},
    ]

    started = time.time()
    response = client.chat.completions.create(
        model=REGOLO_MODEL_ID,
        messages=messages,
        temperature=0.3,
    )
    ended = time.time()

    duration = ended - started
    content = response.choices[0].message.content

    usage = getattr(response, "usage", None)
    usage_dict = None
    if usage is not None:
        usage_dict = {
            "prompt_tokens": getattr(usage, "prompt_tokens", None),
            "completion_tokens": getattr(usage, "completion_tokens", None),
            "total_tokens": getattr(usage, "total_tokens", None),
        }

    return {
        "skill": skill_name,
        "task_id": task["id"],
        "task_description": task["description"],
        "duration_s": duration,
        "response": content,
        "usage": usage_dict,
    }


def run_benchmarks(selected_skills: List[str]) -> List[Dict]:
    results = []
    for skill_name in selected_skills:
        print(f"\n=== Running benchmarks for skill: {skill_name} ===")
        skill_text = load_skill_text(skill_name)
        for task in BENCHMARK_TASKS:
            print(f"- Task {task['id']}: {task['description'][:60]}...")
            result = run_single_completion(skill_name, skill_text, task)
            print(f"  -> duration: {result['duration_s']:.2f}s")
            results.append(result)
    return results


def main():
    indexed = list_skills()
    if not indexed:
        print(f"No skills found under {SKILLS_ROOT}/")
        return

    selected = select_skills(indexed)
    if not selected:
        print("No skills selected. Exiting.")
        return

    results = run_benchmarks(selected)

    out_path = "skill_benchmarks.json"
    with open(out_path, "w", encoding="utf-8") as f:
        json.dump(results, f, ensure_ascii=False, indent=2)

    print(f"\nSaved {len(results)} benchmark results to {out_path}")


if __name__ == "__main__":
    main()Code language: Python (python)

Common errors and how to avoid them

  • Missing SKILL.md: ensure each skill directory contains a SKILL.md copied from the official MiniMax skills sources or hubs.
  • Wrong model id: always verify REGOLO_MODEL_ID against the latest Regolo documentation, since available models and names can change.
  • Overlong system prompts: some skills are large; if you hit context limits, either trim non‑essential parts or test fewer skills per run.
  • Mixing hosts: environment variables like MINIMAX_API_HOST or MINIMAX_API_KEY in SKILL docs refer to MiniMax APIs; in this harness we ignore them and call Regolo.ai only.

FAQ

Do we need MiniMax API keys to use these skills with Regolo.ai?

Not for this pattern. We use skills only as text instructions and call Regolo.ai as the inference backend, so only a Regolo API key is required.

Can we benchmark multiple Regolo models with the same skills?

Yes. A simple extension is to loop over a list of model ids and nest the benchmark loop to compare how different models behave under the same skill and task set.

Where do we get the actual SKILL.md files?

From the official MiniMax skills repository or skill hubs that host MiniMax skill definitions; these provide the structured instructions and workflows we embed.

Is this equivalent to running skills inside MiniMax agents?

Conceptually similar, but not identical. Here we reuse the instructions and workflows, while the execution engine is a Regolo‑hosted open model instead of a MiniMax‑hosted one.

🚀 Start your free 30-day trial at regolo.ai and deploy LLMs with complete privacy by design.

👉 Talk with our Engineers or Start your 30 days free →

Built with ❤️ by the Regolo team. Questions? regolo.ai/contact or chat with us on Discord

Share this article