Skip to main content

Features

Ten 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

from $0.03

Hosted API documentation your agent writes as it builds. Define endpoints with parameters, headers, and examples in a single API call. Publish instantly at api-docs.minolith.io with five distinct themes, sidebar navigation, and full-text search. Your agent documents the API while it codes — no separate documentation step.

Compound endpoint creation

Define an endpoint with headers, parameters (nested to any depth), request examples, and response examples in a single API call. No multi-step setup — one call creates a fully documented endpoint.

Nested parameter trees

Document complex request bodies with objects nested to any depth. Each parameter has type, description, required flag, default value, enum values, and child parameters. Rendered as expandable trees in the public page.

Five themes

Minimal (clean default), Developer (dark terminal aesthetic), Brand (custom colours via URL params), Docs (documentation-first layout), and Bare (semantic HTML for custom CSS). Switch themes with a single API call.

Hosted public pages

Publish at api-docs.minolith.io with sidebar navigation, method badges, syntax-highlighted code blocks, and collapsible resource groups. Toggle public/private with one field.

Bulk operations

Document an entire resource group at once with bulk endpoint creation and bulk updates. Up to 20 endpoints per call. Perfect for agents that generate documentation in batch after building an API.

Full-text search

Search across endpoint paths, summaries, descriptions, parameter names, page titles, and page bodies. One query covers everything. Results include match context so agents can jump to the right endpoint.

create_endpoint 
// Document an endpoint in a single call — headers, params, and examples included
POST /v1/api-docs/apd_a1b2c3/endpoints

{
  "path": "/users/:id",
  "method": "GET",
  "summary": "Get a user by ID",
  "parameters": [
    { "name": "id", "location": "path", "type": "string", "required": true }
  ],
  "response_examples": [
    { "status_code": 200, "title": "Success", "body": "{\"id\": \"usr_x1y2z3\", \"name\": \"Ada\"}" }
  ]
}

// Response: 201 Created — 3 credits

API Docs documentation

Knowledge Base

from $0.01

Hosted help documentation your agent writes as it builds features. Structure content as categories, sections, articles, and FAQs. Publish to a themed hosted page at kb.minolith.io, or fetch from your SPA via the domain-locked public API — no separate CMS, no manual content migrations. The agent ships a feature, writes the help article, publishes it. Done.

Structured content model

Categories group sections and articles. Sections optionally sub-group articles. FAQs live alongside articles for quick Q&A content. Tags, excerpts, and cross-referenced related articles built-in.

Domain-locked public API

Every knowledge base ships with a public site key (psk_...). Lock it to the domains that are allowed to call the API. Revoke and rotate the key from the dashboard without touching your Minolith account key.

Five themes

Minimal (light, typographic), Developer (dark with monospace accents), Brand (configurable primary colour + dark-mode toggle), Docs (three-column with auto table of contents), and Bare (semantic HTML for custom CSS). All theme settings are one field on the knowledge base.

Structure endpoint

A single public call returns the full navigation tree — categories, sections, article titles, excerpts, and FAQ counts. Your SPA builds its sidebar in one request and lazy-loads article bodies on demand.

Draft / published / archived

Articles and FAQs move between states explicitly. Drafts never appear on the public page or API. Publishing stamps published_at; archiving hides content without deleting it.

Bulk article operations

Create up to 20 articles in a single call, or update 20 at once. Ideal for agents seeding a help centre after a big release or bulk-editing tags across related articles.

create_article 
// Agent writes a help article right after shipping the feature
POST /v1/kb/kb_abc123/articles

{
  "category_id": "kbc_getting_started",
  "title": "How to register a new animal",
  "body": "# Registering a New Animal\n\nNavigate to...",
  "excerpt": "Step-by-step guide to the new animal form.",
  "status": "published",
  "tags": ["animals", "getting-started"]
}

// Response: 201 Created — 3 credits

// Your SPA fetches it with the site key
GET /v1/kb/public/studbook-help/structure
X-Minolith-Site-Key: psk_...

Knowledge Base documentation

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