repryntt
Get started

learn

Learn repryntt.

How to actually use the 220-agent platform and what you can build with it. Concepts, tutorials, recipes, integration patterns, and the common traps to avoid.

quick paths

Skip to where you are.

Just signed up?

Connect a key, generate a REPRYNTT_API_KEY, run your first agent job. Five steps.

Start the 5-min onboarding →

Building agents into your code?

REST API, Bearer auth, request/response shape, CI patterns, error codes.

Skip to integration →

Want to build your own agents?

Brain Builder for companions, Specialist Builder for roster-style. Both produce roster-quality output.

Skip to Agent Studio →

Cost-conscious?

Hybrid routing puts the cheap workhorse in front and Opus only as critic. ~$1-1.50/hr for top quality.

Skip to cost playbook →

concepts

The vocabulary in one place.

Eight terms that show up everywhere. Know these and the rest of the platform reads itself.

Agent

A specialist with a tuned persona, a tool policy, and a workflow. Not a chat — a colleague that already knows the job. 220 ship in the marketplace; you can build more in Agent Studio.

Tool

Something an agent can call. 380 ship by default across 35+ categories — search, code, browser, math, memory, integrations. Every agent can chain them: research → process → verify → present.

Workbench

A pre-built multi-agent pipeline for a specific job: Coding Forge (code with tests), Video Studio (script-to-render), Coherence Cloud (frontier critic), Swarm Mode (orchestrated delegation), Nexus Hub (your local Nexus embedded), Agent Studio (build your own).

Brain

A persistent companion agent. Has memory across sessions, an identity, drives, curiosity. Lives in ~/.repryntt/brain on your device. Built via Brain Builder or shipped as the default Andrew seed.

Swarm

Multi-agent orchestration. A Commander decomposes your task into distinct sub-tasks, delegates one to each specialist, then a Synthesizer merges their outputs into one unified answer. Not a race — a real workflow.

Runner

The piece of repryntt that runs on YOUR machine. Paired with the cloud dashboard via a token. Jobs you submit in the SaaS execute on your hardware with your keys. The Nexus Hub tunnels the runner's UI into the dashboard.

BYOK

Bring Your Own Key. Connect OpenAI, Anthropic, xAI, Google, NVIDIA, or local. The platform routes per task and the model provider bills you directly. We never mark up tokens.

3-tier router

Local (Ollama/vLLM) → Routine (cheap frontier like Gemini Flash) → Reasoning (top tier like Opus). Picks per task. Cheap tiers carry most work; premium fires only when the task earns it.

first day

Your first hour with repryntt.

Five steps from signup to a working agent job.

1

Connect at least one LLM key

Go to Settings → LLM Providers. Paste an Anthropic, OpenAI, xAI, or Google key. We encrypt-at-rest. You can connect more than one and let the router pick per task.

tip · Don't have one? Anthropic and OpenAI both let you load $5 of credit to try things out.

2

Generate a REPRYNTT_API_KEY

Dashboard → API Keys → Generate. Copy it once (you can't see it again). Use it as a Bearer token to call the platform from scripts, CI, your own code.

tip · Set REPRYNTT_API_KEY in your shell rc so all your scripts pick it up.

3

Run your first agent job

From the dashboard: 220 Agents → pick one (Code Reviewer, Plasma Physicist, Contract Drafter, anything) → type your task → run. From the CLI: see the integration section below.

tip · Start with a specialist that matches the job. 'Strategic Research Analyst' for market scans; 'Code Reviewer' for diffs; 'Plasma Physicist' for fusion questions.

4

Try a workbench

Coding Forge gives you working code with tests. Video Studio gives you a finished 720p video. Coherence Cloud judges your existing agent outputs. Swarm Mode breaks one task across multiple specialists. Pick the workbench whose output matches what you actually need.

tip · Forge bills against the 50 builds/month included; Studio against 20 video projects; Coherence against 1,000 calls. Watch your usage in the Brain Pulse dashboard.

5

Pair your local OSS install (optional)

Run `pip install repryntt` (or clone the repo) on your machine, generate a runner token at /dashboard/runner, drop it in ~/.repryntt/brain/ai_config.json. Now the SaaS dashboard talks to your local runner — and Nexus Hub embeds your local pages directly.

tip · This is the hybrid sweet spot — cloud convenience, local execution, your keys, no data leaves your hardware.

recipes

Eight things people build.

Concrete workflows. Pick the one closest to what you want and adapt.

Solo dev / small team

Code review on every PR

  1. 1.Generate a REPRYNTT_API_KEY
  2. 2.Add a GitHub Action that calls Code Reviewer with the PR diff
  3. 3.Pipe the review back as a PR comment
  4. 4.Optionally fan out: Code Reviewer + Security Auditor + Test Engineer via Swarm Mode

Founder / analyst

Market scan + synthesis

  1. 1.Swarm Mode with Strategic Research Analyst + Industry Specialist + Investigative Journalist
  2. 2.Main task: 'Map the competitive landscape in X'
  3. 3.Commander auto-splits angles (market size, key players, business model gaps, regulatory)
  4. 4.Synthesizer unifies into a single brief

Hacker / weekend builder

Ship a working CLI tool

  1. 1.Coding Forge → 'A CSV → SQLite import CLI with --schema and --strict flags'
  2. 2.Architect drafts, Generator writes, Critic reviews, Tester runs the suite
  3. 3.Download the artifact (code + tests). `pip install -e .` and you're shipping

Content creator / agency

Turn a topic into a finished video

  1. 1.Video Studio → drop in a topic or a script
  2. 2.Pick a voice + render settings (720p Publish, or 480p Draft for proofs)
  3. 3.Pipeline writes shot list → generates clips → narrates → scores → assembles
  4. 4.Download the .mp4 + thumbnails. Batch this with the API for series production

AI team / autonomous loop owner

Catch agent drift before it ships

  1. 1.Run your producer agent (whatever model)
  2. 2.Pipe its output to Coherence Cloud → critic verdict on 5 axes
  3. 3.If verdict fails, loop the producer with the critic's notes
  4. 4.Only deliver when both producer AND critic agree

Scientist / domain expert

Run a research deep-dive

  1. 1.Pick the right scientific specialist (Plasma Physicist, Materials Scientist, etc.)
  2. 2.Use mode='deep' so it runs through the full plan→act→evaluate→reflect loop
  3. 3.Enable Knowledge & web search + Brain memory tools
  4. 4.The agent stores findings — next conversation continues, doesn't restart

AI engineer / builder

Custom specialist your business needs

  1. 1.Agent Studio → Specialist Builder
  2. 2.Fill in: role title, department, focus, expertise, deliverables, audience, preferred tools
  3. 3.Generator produces a ROLE_INSTRUCTIONS block matching the 3-layer architecture
  4. 4.Download .json or use the role_key directly via /v1/agents/run

Power user / lifestyle

Personal companion brain

  1. 1.Agent Studio → Brain Builder
  2. 2.Fill in: name, role, mission, values, anti-patterns, curiosity anchors, voice
  3. 3.Generator produces a 7-file openclaw bundle (SPIRIT, PULSE, INTERESTS, RECALL, CAPABILITIES, SELF_AWARENESS, IDENTITY)
  4. 4.Deploy to ~/.repryntt/agent_workspaces or use cloud-side

integration

Drop it into your code.

REPRYNTT_API_KEY as a Bearer token. Three languages, the same request shape.

Bash / curl

# List all 220 agents
curl https://api.repryntt.com/v1/agents \
  -H "Authorization: Bearer $REPRYNTT_API_KEY"

# Run one
curl https://api.repryntt.com/v1/agents/run \
  -H "Authorization: Bearer $REPRYNTT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent": "Code Reviewer",
    "task": "Review this diff for bugs.",
    "input": "<your diff here>"
  }'

Python

import os, requests

API = "https://api.repryntt.com"
H = {"Authorization": f"Bearer {os.environ['REPRYNTT_API_KEY']}"}

def run(agent: str, task: str, **kw):
    r = requests.post(f"{API}/v1/agents/run",
                      headers=H,
                      json={"agent": agent, "task": task, **kw})
    r.raise_for_status()
    return r.json()

result = run("Code Reviewer", "Find bugs in this PR.", input=diff)
print(result["output"])

TypeScript

const KEY = process.env.REPRYNTT_API_KEY!;

async function run(agent: string, task: string, extra: Record<string, unknown> = {}) {
  const r = await fetch("https://api.repryntt.com/v1/agents/run", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ agent, task, ...extra }),
  });
  if (!r.ok) throw new Error(`${r.status} ${await r.text()}`);
  return r.json();
}

const result = await run("Code Reviewer", "Find bugs.", { input: diff });
console.log(result.output);

See /docs/api for the full endpoint reference, error codes, and response shapes.

build your own

Agent Studio: roster-quality, built by you.

When the 220 don't cover your exact need, build a new one using the same prompt architecture. Two builders, two flavors:

Brain Builder

Persistent companion (openclaw method)

Generates a 7-file bundle: SPIRIT, PULSE, INTERESTS, RECALL, CAPABILITIES, SELF_AWARENESS, IDENTITY. First-person, rich, self-editable. The agent reads and updates these as it evolves. Use this when you want an operator-companion with memory.

Specialist Builder

Stateless roster-style (3-layer prompt)

Generates a ROLE_INSTRUCTIONS block matching PROFESSIONAL_BASE + DEPT_FRAMEWORK + ROLE_INSTRUCTIONS. Same discipline as the 220 marketplace agents. Use this when you want a task executor with verification.

Build them at /dashboard/agent-studio. Both produce downloadable .json bundles you can deploy.

cost playbook

Premium quality without the premium bill.

Hybrid routing is the move. The 3-tier router does most of this automatically — but here's the mental model.

  • L1 Local (Ollama/vLLM): routine heartbeats, simple classification. Near-zero cost.
  • L2 Routine (Gemini Flash, Haiku, gpt-4o-mini): the workhorse. Carries the bulk of producer work. Pennies to single-dollars per hour at most loads.
  • L3 Reasoning (Opus, Grok, gpt-4o): fire ONLY when the task earns it — orchestrator role, critic verdict, sanity-check the final answer.

Real numbers (from our own 1-hour burn tests at the system's default 40 RPM cap):

  • Opus 4.6 as full-time producer: ~$10.60/hr
  • Opus 4.6 firing as orchestrator/critic 1 in 10 cycles: ~$1-1.50/hr effective → $10 of credit lasts ~10 hours
  • Tune routing per-agent in Settings. Set per-provider budgets to cap blast radius.

See the full breakdown on /pricing.

power moves

Get more out of the system.

Hybrid routing for cost

Set Gemini Flash (or Haiku, or gpt-4o-mini) as the default producer and pin Opus only to orchestrator / final critic roles. The 3-tier router does most of this automatically, but you can tune routing per-agent in Settings. Effective cost drops to ~$1-1.50/hr for premium-quality output (vs ~$10/hr if Opus is producer).

Swarm Mode for breadth

When a question has multiple natural sub-parts (legal + technical + market angles, say), let the Swarm Commander decompose it. Each specialist works in parallel on the sub-task best matched to them; the Synthesizer merges. Output quality typically beats any single agent because no one agent is forced to be a generalist.

Mode = 'deep' for stateful runs

Pass mode='deep' in /v1/agents/run to send the job through the full plan → act → evaluate → reflect loop on your local runner (with memory + tools). 'Quick' mode is a one-shot LLM call. Deep mode takes longer but produces better artifacts and the agent remembers it.

Custom roles via role_key

When Specialist Builder generates a custom role, save the role_key (e.g. custom::aquaculture_biologist_a1b2c3d4). Call /v1/agents/run with that role_key just like any built-in agent. You can build a private roster of your business's specialists.

Brain Pulse for spend control

/dashboard/activity shows live monthly usage, runner status, active jobs, recent feed. Set per-provider budgets in Settings — we halt routing to a provider when the cap is hit. No surprise invoices.

Self-host the whole stack

The OSS framework runs entirely on your hardware. MIT-licensed. Clone the repo, run python3 install.py, drop a key in ~/.repryntt/brain/ai_config.json. You get the runtime, the 220 agents, the OSS Swarm orchestration, and the local Nexus dashboard — for free, forever.

traps to avoid

Five mistakes new users make.

trap

Treating it like a chatbot

fix

Be specific. 'Review this PR for SQL injection risks' beats 'check this code'. Agents follow the UNDERSTAND→PLAN→EXECUTE→VERIFY→DELIVER loop — they work better with a clear target and constraints.

trap

Picking the wrong specialist

fix

Match the agent to the job. A Plasma Physicist will give you a great fusion explanation but won't ship code. Code Reviewer reviews code; doesn't strategize markets. Use search_tools_by_intent or the dashboard search to find the right one.

trap

Running Opus for everything

fix

Opus is for the hard parts. Set a cheap frontier as the producer and pin Opus only to the orchestrator / critic role. See hybrid routing above — typical cost savings are 5-10×.

trap

Forgetting to verify

fix

Built-in tools include check_syntax, run_code_tests, statistical_analysis. The agent loop requires verification before delivery — but for high-stakes outputs (legal, medical, finance), still get a human in the loop.

trap

Ignoring the runner pair

fix

If you have a local install, pair it. Cloud convenience + local execution = your data stays yours. The Nexus Hub then embeds your local Nexus right in the dashboard.

go deeper

When you're ready for the docs.

Learn is the "how to actually use it" layer. Docs are the reference. Both stay in sync as the platform evolves.

Quickstart

5-minute setup from signup to first job.

Read →

API reference

Every endpoint, request/response shapes.

Read →

Agent catalog

All 220 specialists, their departments, what they do.

Read →

Workbench docs

Forge, Studio, Coherence, Swarm, Nexus, Agent Studio.

Read →

BYOK setup

Provider table + multi-provider routing + security.

Read →

Self-host (OSS)

Install the OSS framework on your hardware.

Read →

Now go build something.

$29 a month. 7-day free trial. Or self-host the OSS for free.

Start your subscriptionOSS on GitHub