Build business capabilities with composable primitives
Compose production-ready workflows using reusable Buds and orchestrate them with Branches. Connect your data, trigger workflows, and ship capabilities with observability, governance, and monetization built in.
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 AI logic behaves like a real production service.
Monetization built in
Install privately for clients or publish to the marketplace and earn usage-based royalties automatically.
No-code and code-first workflows
Managed execution environment
Supported models and providers
How Stackmint works
Stackmint gives you a clean mental model for building reliable, governed execution 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 capabilities 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
Trigger workflows 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
Execution model
Agents run inside the Stackmint execution environment with a clear runtime contract so you always know how your code behaves.
Observability & debugging
Every run includes the telemetry you need to debug, tune, and trust your capabilities.
- 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 capabilities—privately for internal use, directly into client environments, or publicly to the Stackmint marketplace.
Mode
1 — Private to your workspace
Perfect for internal automation or proof-of-concept workflows you run for your own team.
Mode
2 — Private to clients
Package your capabilities and deliver them directly into client workspaces—zero implementation effort on their side.
Mode
3 — Public marketplace
List your Buds and Branches on the Stackmint marketplace so any customer can discover, install, and run them.
Monetize your capabilities
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 capabilities 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 ECOSYSTEM
Access docs, templates, and examples to ship faster—and a marketplace that turns your best ideas into recurring revenue.
- Starter templates for common capabilities
- Best-practice guides for Buds and Branches
- Patterns for Salesforce, Slack, HubSpot, and more
- Support from the Stackmint team and partners