Developers

Build with Buds and Branches.

Compose production-ready agents using reusable Buds and orchestrate them with Branches. Connect your data, trigger workflows, and ship agents with observability, governance, and monetization built in.

Start buildingView documentation

Modular by design

Build with small, reusable Buds and wire them into Branches. Swap, reuse, and version without rewriting flows.

Production-grade runtime

Typed I/O, secure context, retries, timeouts, and full traces so agents behave like real production services.

Monetization built in

Install privately for clients or publish to the marketplace and earn usage-based royalties automatically.

How Stackmint works

Stackmint gives you a clean mental model for building reliable, governed agentic workflows. Everything is built around three primitives that map directly to how you already think about systems.

  • Buds - modular logic units that connect to APIs, transform data, or perform isolated tasks.
  • Branches - multi-step workflows that chain Buds with typed input/output mapping.
  • Renderers - UI helpers for forms, tables, previews, and visual output when agents run in end-user interfaces.

Primitive

Buds

Reusable logic modules that encapsulate one piece of functionality. Define schemas, call external systems, and return structured results.

Primitive

Branches

Deterministic, typed workflows that orchestrate Bud execution with sequential or parallel steps, mapping, retries, and approvals.

Runtime

Context engine

Every Bud receives secure context: tokens, workspace metadata, user identity, params, and secrets-enforced by RLS, RBAC, and the Trust Layer.

UI

Renderers

Optional UI components that let your Buds show forms, tables, charts, or formatted output in Stackmint or embedded UIs.

Code-first building

Define Buds in code, compose them into Branches, and trigger workflows from the tools your customers already use.

1 - Define a Bud

Write logic inside a single class, define input/output schema, and export it as a Bud:

export class ExampleBud {
  static id = "bud_example";
  static schema = {
    input: {/* ... */},
    output: {/* ... */}
  };

  async run(input, context) {
    // your logic
    return result;
  }
}

2 - Chain Buds into a Branch

Compose Buds using JSON or the visual Branch Builder:

{
  "steps": [
    { "id": "step1", "bud": "bud_retrieve_deals" },
    {
      "id": "step2",
      "bud": "bud_score_opportunities",
      "input": { "records": "{{step1.output.records}}" }
    }
  ]
}

3 - Trigger workflows

Run agents from the channels your customers already live in:

  • - Cron schedules
  • - Webhooks and HTTP events
  • - CRM updates and pipeline changes
  • - Slack commands and messages
  • - Manual invocation via the client console

Built for type safety and observability

All runs flow through the Stackmint execution engine with typed inputs and outputs, context validation, and structured logs so you can debug quickly and ship with confidence.

Integrations built in

Access enterprise systems with secure, zero-trust token handling. All integrations inherit RLS, RBAC, Trust Layer masking, secret isolation, and full audit trails.

First-class connectors

SalesforceHubSpotSlackGoogle WorkspaceWorkdayZendeskCustom APIsInternal services

Execution model

Agents run inside the Stackmint execution environment with a clear runtime contract so you always know how your code behaves.

- Deterministic, step-by-step execution
- Automatic retries with scoped timeouts
- Error propagation and structured failures
- Token-safe external calls and rate limiting
- Typed input/output validation for every Bud
- Execution history and state snapshots per run

Observability & debugging

Every run includes the telemetry you need to debug, tune, and trust your agents.

  • - Step-by-step traces
  • - Input and output inspection
  • - External API call logs
  • - Performance and latency metrics
  • - Token usage visibility
  • - Error stack traces and event timelines

Local development

Test Buds and Branches locally or in sandbox mode before you roll them out to clients.

  • - Run Bud logic with mocked or live context
  • - Test integrations using your own OAuth tokens
  • - Preview renderer output and UI helpers
  • - Validate schemas before publishing
  • - CLI tools and local harnesses (coming soon)

Publish & distribute

Choose how you ship agents-privately for internal use, directly into client environments, or publicly to the Stackmint marketplace.

Mode

Private to your workspace

Perfect for internal automation or proof-of-concept agents you run for your own team.

Mode

Private to clients

Package your agents and deliver them directly into client workspaces-zero implementation effort on their side.

Mode

Public marketplace

List your Buds and Branches on the Stackmint marketplace so any customer can discover, install, and run them.

Monetize your agents

Stackmint gives you two built-in revenue streams so your IP can compound over time.

Channel

Client installations

Install Buds and Branches directly into your clients' environments. You set pricing and keep most of the revenue on each run-Stackmint charges a small platform fee and handles billing and payouts.

Channel

Marketplace royalties

Publish agents publicly and earn every time someone uses them. Your IP keeps working for you as usage grows.

*Standard revenue share for marketplace usage. Terms may vary for enterprise partners.

Join the developer ecosystem

Access docs, templates, and examples to ship faster-and a marketplace that turns your best ideas into recurring revenue.

  • - Starter templates for common agents
  • - Best-practice guides for Buds and Branches
  • - Patterns for Salesforce, Slack, HubSpot, and more
  • - Support from the Stackmint team and partners
Start buildingBecome a partner