Build on Juggernaut Cloud
Processes, plugins and MCP servers — compiled, versioned and governed, running where your customer runs them: on-prem, behind the firewall, or in your own VPC.
Connectors are code you compile, not configuration you babysit
The TypeScript SDK gives you typed actions, scoped credentials and schema validation for the systems your process has to touch. You build, compile and upload a secure connector; deployment is a single line, and there is no external hosting infrastructure for you to provision, patch or pay for.
- Typed connector definitions with declared scopes and schemas
- Secrets resolved at execution time, never baked into the artifact
- Compiled, versioned artifacts you can roll back like any other release
Your process is a server any assistant can call
Juggernaut Cloud supports Model Context Protocol servers natively, and ships plugins and skills for Claude and Kimi so process creation, management and execution happen from the assistant your team already uses.
Native MCP server support
Expose your process as a Model Context Protocol server. Tools, resources and prompts are declared once and served to any MCP-compatible client.
Claude and Kimi plugins and skills
Ship skills that create processes, manage them and execute them from the assistant your team already works in — no separate console required.
Compile-based learning
A complex task is compiled into a versioned, replayable process rather than left as a fragile prompt that drifts the moment the model changes.
Chain 100+ models, and change your mind in one edit
A single workflow can route different steps to different providers — Google Gemini, OpenAI GPT-4, Anthropic Claude, Mercury 2, DeepSeek, or open-source models you host yourself. Provider choice is configuration, not a rewrite: one bulk-swap changes the model across 30+ workflow steps at once.
- Per-step model selection across a 30-plus-step workflow
- One bulk-swap configuration to move a whole process between providers
- Locally hosted open-source models sit behind the same interface
Execution behaviour you can state, test and rely on
Model output is probabilistic; the machinery around it is not. State persistence, retry, failover and transactional writes are properties of the runtime, so a process behaves the same way on the hundredth run as it did on the first.
State persistence
Every step checkpoints its state, so a long-running process resumes where it stopped instead of restarting from the top.
Automated retry
Retry policy is declared per step — bounded attempts, backoff, and a defined path when the step still will not settle.
Model failover
If a provider degrades or refuses, execution routes to the next approved model without losing the step context.
Execution guarantees
A run reaches a terminal state: completed, awaiting approval, or failed with a reason. Nothing hangs in an unknown state.
Dry-run before commit
Database steps can be executed in dry-run mode so you see the exact statements and affected rows before anything is written.
Transactional writes
Writes are applied transactionally with safe rollback, so a failure partway through does not leave partial data behind.
You see what each run cost before the bill arrives
Token usage and compute credit consumption are attributed to the execution that caused them, in real time. Budget caps stop a runaway loop, and structured traces make any execution reproducible after the fact.
Real-time token tracking
Token consumption is metered as the run executes, attributed to the step and the model that consumed it.
Compute credit attribution
Compute credits are charged back per execution, so cost lands on the process and the team that owns it rather than on one shared bill.
Budget caps
Caps are set per process, team or environment. A run that exceeds its budget stops and reports instead of spending indefinitely.
Structured traces
Each execution emits a structured trace: inputs, policy decisions, model calls, data writes and timing.
Replay
Any execution can be replayed from its trace — with the same inputs, or edited inputs, to reproduce a result or test a fix.
The guardrails are part of the build, not a review at the end
Policy, secrets and redaction are declared alongside your connector code, so a compliant process is the default output of your workflow rather than a later negotiation.
Policy-as-code gates
Gates are written as code and evaluated before an action runs, not reconstructed afterwards from logs.
Secrets handling
Credentials are resolved at execution time from managed storage, scoped to the connector and never written into traces.
Automatic PII masking and redaction
Sensitive fields are detected and redacted before content reaches a model, with the redaction recorded in the trace.
Zero-retention configurations
Runs can be pinned to zero-retention providers and to your own infrastructure, including on-prem and your own VPC.
Exportable audit trails
Audit records are exportable in open formats so they feed the systems your compliance team already uses.
Environment boundaries
Development, staging and production are separate boundaries with their own policy sets, secrets and model allowlists.
A minimal connector
Scoped credentials, schema validation and a declared action — the shape of a plugin connector built with the SDK.
export default defineConnector({
name: 'acme-erp',
version: '1.0.0',
scopes: ['invoice.read', 'invoice.write'],
actions: {
async fetchInvoice({ id }, ctx) {
const token = await ctx.secrets.get("ACME_TOKEN");
const res = await ctx.http.get(`/invoices/${id}`, {
headers: { Authorization: `Bearer ${token}` },
});
return ctx.schema(Invoice).parse(res.data);
},
},
});Illustrative example. Check the documentation for the current API surface before you build against it.
From install to governed production run
Install the SDK
Add the plugin SDK to your project and authenticate the CLI against your Juggernaut Cloud workspace.
Scaffold a connector or process
Generate a typed connector or process definition from a template, then declare the actions, scopes and schema you need.
Compile and upload
Compile locally and push a versioned artifact. Uploads are validated against your policy set before they are accepted.
Run with test inputs
Execute against fixtures with dry-run enabled, inspect the trace, and replay with edited inputs until the behaviour is right.
Ship with governance
Promote to production with budget caps, model allowlists, redaction rules and audit export already attached to the process.
Bring your stack and build the first process
Talk to an engineer about your models, your data boundary and the deployment target you need — on-prem, private VPC, or Juggernaut Cloud.