Skip to main content

Features

Nine services, one API key. Everything your AI coding agents need to be effective across sessions.

Context

Free

A structured knowledge base that your agents build for themselves. 19 entry types — from rules and patterns to workflows and glossary terms — persist across sessions. Entries are independent records filtered by type, tags, scope, and priority. No vector embeddings, no semantic search — structured, typed data with tag-based retrieval and full-text search.

19 entry types

rule, pattern, snippet, decision, fact, warning, event, brief, bug, todo, dependency, config, workaround, workflow, persona, reference, preference, test, glossary. Types are universal — use tags for language or framework-specific scoping.

Tag-based retrieval

Tag entries for fast filtering. Query by type, tags, scope, or priority to get exactly the context you need.

Immutable events

Log deployments, migrations, and incidents as write-once events. Build a timeline of what happened and when.

Query model

Filter entries by type, tags, scope, and priority. Tags are the primary retrieval mechanism — comprehensive tagging at creation time is essential. Discovery endpoints (list_tags, list_scopes) help agents find what's available.

Session tracking

The MCP server tracks tool calls per API key within a 30-minute session. If an agent writes without reading first, the response includes a warning to prevent duplicates and overwrites.

Full-text search

Search across entry titles and bodies with the search parameter. Combine with type, tag, and scope filters for targeted retrieval. Returns results ranked by relevance.

store_context 
// Store a rule — one of 19 entry types your agents use to categorise knowledge
POST /v1/context/entries

{
  "type": "rule",
  "scope": "css",
  "title": "Never inline styles or create per-page CSS",
  "body": "All styles must use the shared stylesheet at assets/css/app.css.",
  "tags": ["css", "styling", "frontend"],
  "priority": "high"
}

// Response: 201 Created
{
  "data": {
    "id": "ctx_a1b2c3d4e5f6",
    "type": "rule",
    "priority": "high",
    "is_immutable": false
  }
}

Context API docs

Changelog

$0.03 / entry

API-first changelog hosting. Your AI tools create entries as they ship features. Group entries into versions, publish to a hosted public page, embed a widget in your app, and serve an RSS feed. Five built-in themes.

Hosted public page

Every project gets a public changelog at changelog.minolith.io. Custom page titles and domain support.

Embeddable widget

Drop a single script tag into your site. Users see a changelog button that opens a slide-out panel.

Version management

Group entries under versions (v1.2.0). Publish individually or publish an entire version at once.

create_changelog_entry 
// Ship a feature? Log it as you go.
POST /v1/changelog/entries

{
  "title": "Add bulk import for CSV files",
  "body": "Users can now import records from CSV files up to 50MB.",
  "category": "feature",
  "version_id": "ver_2c8e4a1b6f3d"
}

// Response: 201 Created — 3 credits
{
  "data": {
    "id": "ent_7f3a9b2c4d1e",
    "status": "draft",
    "category": "feature"
  }
}

Changelog API docs Changelog guide

Feedback

$0.01 / item

Collect structured user feedback through an embeddable widget or API. Bug reports, feature ideas, questions, and praise land in a dashboard inbox. Your agents can query feedback via MCP to understand what users are asking for.

Widget integration

One script tag gives your users a feedback button. Captures browser info, page URL, and screen size automatically.

Status workflow

Move items through: new, acknowledged, planned, in progress, resolved, closed. Add internal notes at every stage.

Agent-queryable

Your AI agents can read feedback via MCP and factor user needs into their work without you relaying anything.

submit_feedback 
// Collect structured feedback
POST /v1/feedback/items

{
  "title": "Search is slow",
  "body": "15s to load 10k+ results.",
  "type": "bug",
  "tags": ["performance"],
  "user_name": "Alice Chen"
}

// 201 Created — 1 credit

Feedback API docs Widget guide

Runbooks

$0.05 / template

Define multi-step procedures that your agents follow consistently. Deployments, incident response, onboarding — any repeatable process. Runs persist across sessions, so an interrupted agent picks up exactly where it left off.

Step types

Action (do something), check (verify), gate (wait for human approval), and branch (conditional routing).

Variables

Define placeholders resolved at run time. Deploy the same runbook to staging and production with different values.

Persistent progress

Every step completion is recorded. Resume from exactly where you stopped, even across different agent sessions.

create_runbook 
// Define a deployment procedure with branching
POST /v1/runbooks/

{
  "name": "Production Deploy",
  "variables": [
    { "name": "version", "required": true },
    { "name": "environment", "default": "production" }
  ],
  "steps": [
    { "label": "Run test suite", "type": "check",
      "next_on_outcome": { "pass": "step:deploy", "fail": "step:fix" } },
    { "label": "Fix failures", "ref": "fix" },
    { "label": "Deploy {version}", "ref": "deploy" },
    { "label": "Verify health checks", "type": "gate" }
  ]
}

Runbooks API docs

Agents

$0.03 / agent

Define agent identities — role, system prompt, available tools, and context requirements. Bootstrap loads an agent's full definition plus relevant context in a single API call. Browse and install templates from the community registry.

Subagent system

Define parent-child relationships. A lead agent can load subagent definitions and delegate work with full context.

Community registry

Browse curated agent templates. Install with one call and customise for your project.

Pre-resolved context

When bootstrap loads an agent, it executes the agent's context_requirements queries and returns matching Context entries inline. Subagents start with project knowledge already loaded — no additional API calls needed.

create_agent + bootstrap 
// Define a code reviewer agent
POST /v1/agents/

{
  "name": "code-reviewer",
  "role": "Reviews code for correctness, style, and bugs.",
  "tools_allowed": ["file_read", "bash:grep", "bash:git"],
  "tools_denied": ["file_write", "bash:rm"],
  "context_requirements": [
    { "type": ["rule", "pattern"], "tags": ["code-review"] }
  ]
}

// Then at session start — one call loads everything
GET /v1/bootstrap  // Free

Agents API docs

Bootstrap

Free

One API call at session start and your agent knows everything — its identity, project rules, active work, what changed since last session, and what to do next. No manual setup, no multi-step init scripts, no forgotten context. Bootstrap replaces the entire session-start workflow with a single request.

Everything in one call

Agent definition, system prompt, high-priority context, subagent list, active runbook runs, open feedback counts, recent events, styleguide summary, and follow-up suggestions — all returned in a single response.

Adaptive response size

Bootstrap auto-detects when the response is too large and switches to a slim format — context titles only, styleguide counts only. Small projects get everything inline; large projects get pointers to fetch what they need.

Session-aware

Tracks when each agent last bootstrapped. Returns new context entries, updated entries, and new high-priority items since the last session — so agents know what changed without diffing.

Follow-up suggestions

Bootstrap analyses project state and suggests next actions. Open high-priority feedback? It tells the agent to call list_feedback. Active runbook run? It suggests resuming. The agent starts working immediately.

Prompt injection

Tag context entries with "bootstrap" and they're delivered as prompt-level instructions every session. Rules, workflows, communication style — loaded automatically without the agent needing to query.

Zero cost

Bootstrap is free. Call it at the start of every session. No credits, no limits, no metering. It's how your agents should begin every conversation.

bootstrap 
// One call at session start — everything your agent needs
GET /v1/bootstrap  // Free — no credits

// Response
{
  "agent": {
    "name": "orchestrator",
    "role": "Lead developer for the project.",
    "prompt": "Follow established patterns..."
  },
  "prompt": [/* bootstrap-tagged context entries */],
  "context": [/* 20 high-priority entries */],
  "subagents": [
    { "name": "code-reviewer", "role": "Reviews code changes." },
    { "name": "security-auditor", "role": "Checks for vulnerabilities." }
  ],
  "active_state": {
    "event_count": 94,
    "open_feedback": { "total": 3, "high_priority": 1 }
  },
  "changes_since_last_session": {
    "new_entries": 5,
    "updated_entries": 2
  },
  "follow_up": [
    { "tool": "list_feedback", "reason": "1 high-priority item is open." }
  ]
}

Bootstrap API docs

Styleguide

from $0.02

A structured design system your agent queries before building any UI. Design tokens, component definitions, layout patterns, voice conventions, and managed image assets — all stored as structured data, queryable via REST API and MCP tools. Your agent builds consistent UI without guessing.

Design tokens

Colours, spacing, typography, breakpoints, and shadows — stored as structured key-value sections. Create or replace entire token sections at once. 2 credits per section.

Component definitions

Define reusable UI components with variants, props, usage rules, and example markup. Your agent looks up the component before writing any HTML. 3 credits per component.

Layout patterns

Capture layout conventions — page structures, grid systems, responsive breakpoints, and spacing rules. Agents query patterns before scaffolding any page. 2 credits per pattern.

Voice conventions

Tone, terminology, forbidden words, and writing style rules. Ensures every agent-written label, message, and paragraph matches your brand voice. 2 credits per rule set.

Managed assets

Upload images, icons, and other binary assets. Each asset gets a permanent URL your agent can reference in markup. 3 credits per upload.

All reads are free

Querying tokens, components, patterns, voice rules, and assets costs nothing. Updates and deletes are free too — you only pay when creating new entries.

styleguide tokens + components 
// Store design tokens — colours, spacing, typography
POST /v1/styleguide/tokens

{
  "section": "colours",
  "tokens": {
    "primary": "#00d4aa",
    "surface": "#14141e",
    "text": "#eaeaf0"
  }
}

// Response: 201 Created — 2 credits

// Define a component
POST /v1/styleguide/components

{
  "name": "Button",
  "variants": ["primary", "outline", "ghost"],
  "usage": "Use .btn-primary for main CTAs, .btn-outline for secondary actions."
}

// Response: 201 Created — 3 credits

Styleguide API docs

Tasks

$0.02 / task

A shared task list where your agents and your team are peers. Create tasks, assign them to agents or team members, track progress through configurable workflows, and use the team feed to see what everyone is working on. The agent calls get_my_tasks at session start and knows exactly what to work on.

Configurable workflows

Define your own status pipeline: open, in_progress, review, qa, done. Solo plan gets the fixed open → review → done workflow. Team plans can customise up to 10 statuses.

Notes timeline

Comments, status changes, assignments, and git commits accumulate on each task. The human reviews and adds feedback. The agent reads it next session. No conversation needed.

Team feed

A chronological log of all task activity across the project. Query with since to see what happened since your last session. Agents start with full situational awareness.

Agent identity

The X-Minolith-Agent header identifies which agent is acting. Notes and status changes are attributed to the named agent. Bootstrap returns only that agent's assigned tasks.

Assignment & review loop

Assign a task to an agent. The agent works it, adds notes, moves to review. You review, add feedback, send it back. The agent picks it up next session. Async collaboration without conversation.

Only creation costs credits

Task creation costs 2 credits. Everything else is free: status changes, assignments, notes, the feed, workflow configuration, and all reads. The coordination is the value.

tasks workflow 
// Agent calls get_my_tasks at session start
GET /v1/tasks/mine  // Free

{
  "data": {
    "open": [
      { "id": "tsk_a1b2c3", "title": "Fix CSV export crash", "priority": "urgent" }
    ],
    "review": [],
    "done": []
  },
  "workflow": ["open", "review", "done"],
  "total": 1
}

// Agent works the task, then moves to review
POST /v1/tasks/tsk_a1b2c3/status

{
  "status": "review"
}

Tasks API docs

API Docs

Hosted API documentation your agent writes as it builds.

Compound endpoint creation

Define an endpoint with headers, parameters (nested), request examples, and response examples in a single API call.

Nested parameter trees

Document complex request bodies with objects nested to any depth. Rendered as expandable trees in the public page.

Five themes

Minimal, Developer (dark), Brand (custom colours), Docs (documentation style), and Bare (semantic HTML for custom CSS).

Hosted public pages

Publish at api-docs.minolith.io with sidebar navigation, search, method badges, and syntax-highlighted code blocks.

Bulk operations

Document an entire resource group at once with bulk endpoint creation. Up to 20 endpoints per call.

Full-text search

Search across endpoint paths, summaries, descriptions, parameter names, page titles, and page bodies.

API Docs API docs

Teams

from $15 / mo

Collaborate on AI agent infrastructure without friction. Invite team members by email, assign them to projects with admin or member roles, and share a single credit pool. No per-seat charges — add as many people as you need. All usage bills to the team owner's subscription.

Roster model

One team per account. Invite members by email — they accept the invite and appear on your roster. Remove members any time with immediate effect.

Per-project roles

Assign each member an admin or member role per project. Admins can manage project settings and API keys. Members get read/write access to project data. Access is scoped per project — a member can be admin on one project and member on another.

One credit pool

All usage across all team members and all shared projects draws from the team owner's subscription credits. No per-seat billing, no individual credit allocations to track.

Unlimited members

Add your whole team. The plan covers the credits, not the headcount. Grow your team without worrying about seat costs.

Independent projects

Team members can create and manage their own projects independently. Shared projects appear alongside their personal ones in the dashboard.

Owner billing

The team owner holds the subscription. When a member creates data in a shared project, those credits come from the owner's account — no separate billing setup per person.

Teams guide

API + MCP

Included

Every service is accessible via both a REST API and a native MCP server. One API key authenticates across all services. JSON responses, cursor-based pagination, structured errors with suggestions. Built for machines, documented for humans.

REST API

Hosted service at api.minolith.io — no local installation, no npm packages, no Docker containers. Bearer token auth (mlth_ prefixed keys), JSON request/response, 300ms rate limit per key.

MCP server

JSON-RPC 2.0 over HTTP at mcp.minolith.io. Connect with claude mcp add or any MCP-compatible client.

Structured errors

Every error includes a code, message, field reference, docs URL, and a suggestion for how to fix it.

connect 
# Connect via MCP
$ claude mcp add minolith \
  https://mcp.minolith.io

# Or call the REST API
$ curl -H "Authorization: Bearer mlth_..." \
  https://api.minolith.io/v1/context/entries

# Structured errors
{
  "error": {
    "code": "validation_error",
    "suggestion": "Valid types: rule..."
  }
}

Platform API docs

Ready to get started?

14-day free trial with 500 credits. No card required.

Start free trial