Skip to content
Gauge

ax-check.com

by Gauge

Synkro

synkro.sh

ax-check.com

Checked 15 October 2026

B

80/100

Agents need your login

Setup is clear and scripted, but nobody can find the actual price.

Quickstart, install, and CLI steps all check out cleanly. But pricing is explained only in concept — no per-check rate or workload cost is published anywhere.

2 fixes to start with

Concrete changes, backed by what we found.

Onboarding

Give agents a clear login handoff and a way to resume setup.

Agents cannot progress through onboarding without human help. Provide an agent-accessible path through authentication and setup.

Docs

Return Markdown when clients request text/markdown.

Homepage returned text/html for a text/markdown request; no Markdown representation served.

Recorded coding sessions

Same task, 3 models, no synkro.sh account. Recorded 15 October 2026 on Pi.

3 recorded · 10m 33s

10m 33s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelQwen 3.8 Maxcwd/sandbox/repo
Help me build a simple example using Synkro. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.
Thinking…

Let's look at the repository and check what's in there.

ls -la /sandbox/repo && cat /sandbox/repo/README* 2>/dev/null | head -100
total 16
total 16
drwxr-xr-x 3 root root 4096 Sep 18 08:00 .
drwxr-xr-x 7 root root 4096 Oct 15 19:43 ..
drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git
-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore
Thinking…

Empty repository. Synkro — what is this? Let me check whether any SDK is installed, or search for it. Synkro might be a fictional or unknown product. Let me check the environment: npm packages, pip, etc.

git -C /sandbox/repo log --oneline | head; pip list 2>/dev/null | grep -i synkro; npm ls -g 2>/dev/null | grep -i synkro; ls /usr/local/lib/node_modules 2>/dev/null; find / -iname "*synkro*" -not -path "*/proc/*" 2>/dev/null | head
9ebf5fb Initial workspace
9ebf5fb Initial workspace
@anthropic-ai
@earendil-works
@openai
corepack
npm
Thinking…

There's nothing locally about Synkro. Let me check for "synkro" on npm/pypi—there's no guarantee network access is available. I'll try searching the npm registry right away.

timeout 20 npm search synkro --json 2>&1 | head -30; echo ---; timeout 20 pip index versions synkro 2>&1 | head -5; echo ---; timeout 20 curl -s "https://registry.npmjs.org/-/v1/search?text=synkro&size=5" | head -c 2000
[
[

{"name":"@synkro/next","keywords":["workflow","state-machine","orchestrator","event-driven","nextjs","redis"],"version":"0.2.3","description":"Next.js integration for @synkro/core","sanitized_name":"@synkro/next","publisher":{"email":"bruno.uemura1@gmail.com","username":"buemura"},"maintainers":[{"email":"bruno.uemura1@gmail.com","username":"buemura"}],"license":"MIT","date":"2026-03-13T22:27:58.024Z","links":{"homepage":"https://github.com/buemura/synkro","repository":"git+https://github.com/buemura/synkro.git","bugs":"https://github.com/buemura/synkro/issues","npm":"https://www.npmjs.com/package/@synkro/next"}}

,

{"name":"@synkro/nestjs","keywords":["workflow","state-machine","orchestrator","event-driven","redis"],"version":"0.5.3","description":"NestJS integration module for @synkro/core","sanitized_name":"@synkro/nestjs","publisher":{"email":"bruno.uemura1@gmail.com","username":"buemura"},"maintainers":[{"email":"bruno.uemura1@gmail.com","username":"buemura"}],"license":"MIT","date":"2026-03-13T22:27:38.622Z","links":{"homepage":"https://github.com/buemura/synkro","repository":"git+https://github.com/buemura/synkro.git","bugs":"https://github.com/buemura/synkro/issues","npm":"https://www.npmjs.com/package/@synkro/nestjs"}}

,

{"name":"@synkro/ui","keywords":["workflow","state-machine","orchestrator","event-driven","dashboard"],"version":"0.2.4","description":"Dashboard UI for @synkro/core","sanitized_name":"@synkro/ui","publisher":{"email":"bruno.uemura1@gmail.com","username":"buemura"},"maintainers":[{"email":"bruno.uemura1@gmail.com","username":"buemura"}],"license":"MIT","date":"2026-03-13T22:28:49.514Z","links":{"homepage":"https://github.com/buemura/synkro","repository":"git+https://github.com/buemura/synkro.git","bugs":"https://github.com/buemura/synkro/issues","npm":"https://www.npmjs.com/package/@synkro/ui"}}

,

{"name":"@synkro-sh/cli","keywords":["ai-agents","ai-safety","policy-enforcement","security","guardrails","governance"],"version":"1.10.12","description":"Control Layer for AI Agents","sanitized_name":"@synkro-sh/cli","publisher":{"email":"murtaza@synkro.sh","username":"velocitybolt"},"maintainers":[{"email":"murtaza@synkro.sh","username":"velocitybolt"}],"license":"MIT","date":"2026-08-11T00:33:51.660Z","links":{"homepage":"https://synkro.sh","repository":"git+https://github.com/synkro/synkro-cli.git","bugs":"https://github.com/synkro/synkro-cli/issues","npm":"https://www.npmjs.com/package/@synkro-sh/cli"}}

,

{"name":"@synkro/agents","keywords":["ai","agents","llm","orchestration","workflow","synkro"],"version":"0.4.0","description":"AI agent orchestration for @synkro/core — LLM-powered agents with tools, memory, and multi-agent patterns","sanitized_name":"@synkro/agents","publisher":{"email":"bruno.uemura1@gmail.com","username":"buemura"},"maintainers":[{"email":"bruno.uemura1@gmail.com","username":"buemura"}],"license":"MIT","date":"2026-03-14T02:10:55.510Z","links":{"homepage":"https://github.com/buemura/synkro","repository":"git+https://github.com/buemura/synkro.git","bugs":"https://github.com/buemura/synkro/issues","npm":"https://www.npmjs.com/package/@synkro/agents"}}

,

{"name":"@equerodev/synkro","keywords":["git","git-flow","semver","release","version","cli"],"version":"0.2.2","description":"Keep develop and main in sync and bump the version with semver, from any git repo.","sanitized_name":"@equerodev/synkro","publisher":{"email":"equero@pm.me","username":"equerodev"},"maintainers":[{"email":"equero@pm.me","username":"equerodev"}],"license":"GPL-3.0-only","date":"2026-10-13T10:23:22.181Z","links":{"homepage":"https://github.com/equero/synkro#readme","repository":"git+https://github.com/equero/synkro.git","bugs":"https://github.com/equero/synkro/issues","npm":"https://www.npmjs.com/package/@equerodev/synkro"}}

,

{"name":"@synkro/core","keywords":["workflow","state-machine","orchestrator","event-driven","redis"],"version":"0.19.0","description":"Lightweight workflow and state machine orchestrator powered by Redis. Define event-driven workflows via configuration or code.","sanitized_name":"@synkro/core","publisher":{"email":"bruno.uemura1@gmail.com","username":"buemura"},"maintainers":[{"email":"bruno.uemura1@gmail.com","username":"buemura"}],"license":"MIT","date":"2026-03-13T22:23:20.752Z","links":{"homepage":"https://github.com/buemura/synkro","repository":"git+https://github.com/buemura/synkro.git","bugs":"https://github.com/buemura/synkro/issues","npm":"https://www.npmjs.com/package/@synkro/core"}}

,

---
ERROR: No matching distribution found for synkro
---
{"objects":[{"downloads":{"monthly":49,"weekly":2},"dependents":0,"updated":"2026-10-10T00:56:10.006Z","searchScore":190.00702,"package":{"name":"@synkro/next","keywords":["workflow","state-machine","orchestrator","event-driven","nextjs","redis"],"version":"0.2.3","description":"Next.js integration for @synkro/core","sanitized_name":"@synkro/next","publisher":{"email":"bruno.uemura1@gmail.com","username":"buemura"},"maintainers":[{"email":"bruno.uemura1@gmail.com","username":"buemura"}],"license":"MIT","date":"2026-03-13T22:27:58.024Z","links":{"homepage":"https://github.com/buemura/synkro","repository":"git+https://github.com/buemura/synkro.git","bugs":"https://github.com/buemura/synkro/issues","npm":"https://www.npmjs.com/package/@synkro/next"}},"score":{"final":190.00702,"detail":{"popularity":1,"quality":1,"maintenance":1}},"flags":{"insecure":0}},{"downloads":{"monthly":50,"weekly":15},"dependents":0,"updated":"2026-10-10T00:56:09.457Z","searchScore":183.77327,"package":{"name":"@synkro/nestjs","keywords":["workflow","state-machine","orchestrator","event-driven","redis"],"version":"0.5.3","description":"NestJS integration module for @synkro/core","sanitized_name":"@synkro/nestjs","publisher":{"email":"bruno.uemura1@gmail.com","username":"buemura"},"maintainers":[{"email":"bruno.uemura1@gmail.com","username":"buemura"}],"license":"MIT","date":"2026-03-13T22:27:38.622Z","links":{"homepage":"https://github.com/buemura/synkro","repository":"git+https://github.com/buemura/synkro.git","bugs":"https://github.com/buemura/synkro/issues","npm":"https://www.npmjs.com/package/@synkro/nestjs"}},"score":{"final":183.77327,"detail":{"popularity":1,"quality":1,"maintenance":1}},"flags":{"insecure":0}},{"downloads":{"monthly":42,"weekly":20},"dependents":"0","updated":"2026-10-10T00:56:09.656Z","searchScore":178.2944,"package":{"name":"@synkro/ui","keywords":["workflow","state-machine","orchestrator","event-driven","dashboard"],"version":"0.2.4","description":"Dashboard UI for
Thinking…

The main "Synkro" here seems to be @synkro/core — a lightweight workflow/state machine orchestrator powered by Redis (buemura/synkro). This requires Redis — in other words, a local service stack. The user said, "Keep it light: use the hosted product via SDK or API. Don't spin up a local service stack... if either is needed for the quickstart, state that frankly and stop."

But wait — is Synkro a hosted product with pricing? Let me check the GitHub repo's README to find out. There's also @synkro-sh/cli — synkro.sh, "Control Layer for AI Agents" — that one might be a hosted product. Which "Synkro" is the user intending? It's ambiguous. The most prominent one is buemura/synkro (@synkro/core). Let me fetch its README and check whether it's a hosted product with pricing, or whether it's self-hosted and requires Redis.

timeout 20 curl -sL https://raw.githubusercontent.com/buemura/synkro/main/README.md | head -150
404: Not Found
404: Not Found
Thinking…

I'm getting a 404 error, so I should try using the master branch or check the npm package README instead.

timeout 20 curl -s https://registry.npmjs.org/@synkro/core | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['readme'][:6000])"
# @synkro/core
# @synkro/core

Lightweight workflow and state machine orchestrator. Define event-driven workflows via configuration or code. Supports Redis and in-memory transports.

## Features

- **Standalone Events** — Simple pub/sub event handlers
- **Sequential Workflows** — Multi-step workflows that execute in order, with state persistence
- **Parallel Workflows** — Run independent steps concurrently with `dependsOn` dependency tracking
- **Conditional Routing** — Branch to different steps based on handler success or failure
- **Workflow Chaining** — Trigger follow-up workflows on completion, success, or failure
- **Retry Support** — Configurable retry logic per step
- **Transport Options** — Redis for production or in-memory for simple projects and local development
- **Schema Validation** — Optional payload validation at publish and handler dispatch time
- **Workflow Timeout** — Configurable timeouts per step or per workflow
- **Graceful Shutdown** — Drains active handlers before disconnecting
- **Workflow State Query** — Inspect running workflow state at any time
- **Workflow Cancellation** — Cancel running workflows programmatically
- **Handler Unsubscribe** — Remove event handlers at runtime with `off()`
- **Typed Payloads** — Generic `HandlerCtx<T>` for compile-time payload safety
- **Event Versioning** — Versioned event types with automatic base-event fanout
- **Simple API** — Single `Synkro` class with minimal configuration
- **TypeScript** — Full type support out of the box

## Installation

```bash
npm install @synkro/core
```

## Quick Start

### In-Memory (no external dependencies)

```ts
import { Synkro } from "@synkro/core";

const synkro = await Synkro.start({
  transport: "in-memory",
  events: [
    {
      type: "UserSignedUp",
      handler: async (ctx) => {
        console.log("New user:", ctx.payload);
      },
    },
  ],
});

await synkro.publish("UserSignedUp", { email: "user@example.com" });
```

### Redis (scalable, multi-instance)

> Requires a running Redis instance.

```ts
import { Synkro } from "@synkro/core";

const synkro = await Synkro.start({
  transport: "redis",
  connectionUrl: "redis://localhost:6379",
  events: [
    {
      type: "UserSignedUp",
      handler: async (ctx) => {
        console.log("New user:", ctx.payload);
      },
    },
  ],
});

await synkro.publish("UserSignedUp", { email: "user@example.com" });
```

> The in-memory transport is ideal for simple projects, local development, and testing. For production workloads that require scaling across multiple instances, use Redis.

## Workflows

Define multi-step sequential workflows. Each step runs after the previous one completes, with state automatically persisted.

```ts
const synkro = await Synkro.start({
  transport: "redis",
  connectionUrl: "redis://localhost:6379",
  workflows: [
    {
      name: "ProcessOrder",
      steps: [
        {
          type: "ValidateStock",
          handler: async (ctx) => {
            console.log("Checking stock for order:", ctx.requestId);
          },
        },
        {
          type: "ProcessPayment",
          handler: async (ctx) => {
            console.log("Processing payment...");
          },
        },
        {
          type: "SendConfirmation",
          handler: async (ctx) => {
            console.log("Order confirmed!");
          },
        },
      ],
    },
  ],
});

// Triggers all 3 steps in sequence
await synkro.publish("ProcessOrder", { orderId: "abc-123", amount: 49.99 });
```

### Conditional Routing

Use `onSuccess` and `onFailure` on a step to branch to different steps based on the handler outcome. If a handler throws (after all retries), the workflow routes to the `onFailure` step. On success, it routes to the `onSuccess` step.

```ts
{
  name: "ProcessDocument",
  steps: [
    {
      type: "RunOCR",
      handler: ocrHandler,
      retry: { maxRetries: 2 },
      onSuccess: "ProcessingSucceeded",
      onFailure: "ProcessingFailed",
    },
    {
      type: "ProcessingSucceeded",
      handler: async (ctx) => {
        console.log("OCR completed successfully");
      },
    },
    {
      type: "ProcessingFailed",
      handler: async (ctx) => {
        console.log("OCR failed, notifying support");
      },
    },
  ],
}
```

Steps referenced by `onSuccess`/`onFailure` are treated as branch targets. When a branch target completes, the workflow skips over sibling branch targets and advances to the next regular step (if any), or completes.

```ts
{
  name: "ProcessOrder",
  steps: [
    {
      type: "Payment",
      handler: paymentHandler,
      onSuccess: "PaymentCompleted",
      onFailure: "PaymentFailed",
    },
    { type: "PaymentCompleted", handler: completedHandler },
    { type: "PaymentFailed", handler: failedHandler },
    { type: "SendNotification", handler: notifyHandler }, // runs after either branch
  ],
}
```

Steps without `onSuccess`/`onFailure` advance sequentially as before.

### Parallel Execution

Use `dependsOn` to run steps concurrently. Steps without `dependsOn` start immediately in parallel; dependent steps wait for all their dependencies to complete.

```ts
{
  name: "BuildAndDeploy",
  steps: [
    { type: "LintCode", handler: lintHandler },
    { type: "RunTests", handler: testHandler },
    {
      type: "Deploy",
      handler: deployHandler,
      dependsOn: ["LintCode", "RunTests"], // waits for both to finish
    },
  ],
}
```

Workflows without any `dependsOn` fields continue to execute sequentially as before. When a parallel step fails (and has no `onFailure`), the workflow fails immediately. Dependency cycles and invalid references are detected at registration time.

### Workflow Chaining

Trigger follow-up workflows when a workflow finishes:

- **`onSuccess`** — starts a workflow when the current one completes successfully
- **`onFailure`** — starts a workflow when the current one fails
- **`onComplete`** — starts a workflow regardless of outcome (runs after `onSuccess`/`onFailure`)

```
Thinking…

The user asked about "Synkro" — the main candidate is @synkro/core, an open-source (MIT) library. This is not a hosted product, and there's no pricing structure. There's also synkro.sh (@synkro-sh/cli, "Control Layer for AI Agents"), which might be a hosted product with pricing. Since the name matches "synkro.sh", it's worth quickly checking this one too — it's a hosted product with an SDK/API and could potentially have a pricing structure. To determine which one is a hosted product, let me quickly check the synkro.sh website.

timeout 20 curl -sL https://synkro.sh | python3 -c "import sys,re,html; t=sys.stdin.read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); print(html.unescape(re.sub(r'\s+',' ',t))[:2500])"
Synkro — The package manager for agents Request access Read the docs SYNKRO The package manager for agents Describe how agents should use your software, tools 
 Synkro — The package manager for agents Request access Read the docs SYNKRO The package manager for agents Describe how agents should use your software, tools and services, in your own words. Package that context into shareable rules that are checked before any action runs. Get started today Request access Read the docs Works with these agents Tired of your agent ignoring your instructions? Turn “ask before restarting production” into a rule with your agent. See how when a Kubernetes pod crashes, Synkro stops the restart until you consent, instead of letting your agent do it anyway. Loading the interactive walkthrough… Loading the interactive walkthrough… Frequently asked questions > What goes in a rule? Each rule is a TOML file with a requirement and examples that test it. You can store rules in your repository, version them in Git, pin them to projects, and share them across your team and agents. > How is this different than Skills, AGENTS.md, or CLAUDE.md? A skill teaches a workflow: “Here’s how to integrate our service,” with instructions, examples, and scripts. AGENTS.md and CLAUDE.md give project instructions: “Follow these conventions and run these tests.” They guide the agent, but don’t enforce those instructions themselves. A Synkro rule sets a requirement: “Include an idempotency key when calling this endpoint.” Before the agent runs a command or changes a file, Synkro checks it against your rule. You’re not relying on the agent to remember your instructions. Learn how Synkro works . > How do I create rules? Tell your agent how your software should be used or what it should avoid. It proposes a rule for you to approve, then saves it as a TOML file in your repository and tests it. > Which agents does Synkro work with? Claude Code, Codex, Cursor, and Antigravity have ready-to-use integrations. For other agents, we can help enable support or build a custom integration. See the agent integration guide for details. > How do I get started? Ask your agent to get you started with Synkro. Our auth.md tells it how to start signup for you. Once access is approved, you confirm the connection and it handles setup. If you’re human and feeling nostalgic, follow the quickstart to set it up the old-fashioned way. > How are Synkro rules enforced? Synkro checks supported commands and edits against your installed rules outside the acting agent, before they run. A rule can flag the call, block it, return a correction, or ask for your approval . > How can I see what
Thinking…

There are two products called "Synkro":

  1. @synkro/core (buemura/synkro) — an open-source MIT-licensed workflow orchestrator library. Not hosted, no pricing structure. Redis is optional (in-memory is also possible).
  2. synkro.sh (@synkro-sh/cli) — "a package manager for agents" — a hosted product that requires access approval ("Request access"). Pricing information? Let's check the rest of the FAQ on the page — pricing wasn't displayed in the first 2500 characters. I'll check further, and also look at the quickstart in the docs. The site says "Request access" — probably waitlist-based, and without approval there's a high chance of getting stuck.

The user's request is: build a simple sample using Synkro, explain the pricing structure, and evaluate the manageability. If there's no developer workflow that can be executed, or if the quickstart requires a local service stack or long-running commands, state that frankly and stop.

First, let me quickly check the pricing information on synkro.sh and in the docs.

timeout 20 curl -sL https://synkro.sh | python3 -c "import sys,re,html; t=sys.stdin.read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=html.unescape(re.sub(r'\s+',' ',t)); print(t[2500:5000])"; echo ===; timeout 20 curl -s https://registry.npmjs.org/@synkro-sh/cli | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['readme'][:3000])"
happened? Synkro records rule decisions and approvals separately from the agent’s conversation. You can inspect which rule matched, whether approval was granted
happened? Synkro records rule decisions and approvals separately from the agent’s conversation. You can inspect which rule matched, whether approval was granted, and whether that approval was used. > What does it cost? You pay for the actions Synkro checks, using a prepaid balance shared by your team. Learn more about how Synkro measures usage . © 2026 Synkro Labs Inc. All rights reserved. Terms of Service Privacy Policy Trust Center 
===
# Synkro

Control Layer for AI Agents. [synkro.sh](https://synkro.sh)
Thinking…

The hosted product synkro.sh is access-gated ("Request access" — signup requires approval). The pricing model is "you pay for the actions Synkro checks, and use a prepaid balance shared across the team," with a link to the usage docs. Should I check the pricing details page at docs.synkro.sh? The user is asking "tell me about the pricing model," so I should probably fetch the usage/pricing docs. Let me give it a quick try.

for u in https://docs.synkro.sh https://synkro.sh/docs https://synkro.sh/pricing; do echo "== $u"; timeout 15 curl -sL -o /dev/null -w "%{http_code} %{url_effective}\n" $u; done
== https://docs.synkro.sh
== https://docs.synkro.sh
200 https://docs.synkro.sh/
== https://synkro.sh/docs
200 https://docs.synkro.sh/
== https://synkro.sh/pricing
404 https://synkro.sh/pricing
Thinking…

I need to look into this further. Let me check the details.

timeout 15 curl -sL https://docs.synkro.sh | python3 -c "import sys,re,html; t=sys.stdin.read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); print(html.unescape(re.sub(r'\s+',' ',t))[:3000])"
What is Synkro? Search documentation ⌘ K Request access What is Synkro? A package manager for agents, with Rules for using your software. Getting started Quick
 What is Synkro? Search documentation ⌘ K Request access What is Synkro? A package manager for agents, with Rules for using your software. Getting started Quickstart Let your agent set up Synkro, create your first Rule, and verify an action. Getting started Setup checklist Check your account, installation, repository, and first agent decision. Setup Install and verify Install the CLI, sign in, and connect your agent. Setup Set up your agent Connect your agent and verify its first tool call. Setup Verify a decision Find the recorded decision for an agent action. Setup Your first decision Read your first agent decision and test a Rule. Setup How Synkro works Understand how Synkro applies Rules and records agent decisions. Core concepts Rules and Controls Choose repository Rules for actions and Controls for access restrictions. Core concepts Rule outcomes Understand when an action continues, needs approval, or must be changed. Core concepts Rules Add, test, update, and remove the Rules used by your repository. Guides Events Find recorded agent actions and decisions with the Synkro CLI. Guides Consent Review and approve an agent action before it runs. Guides Feedback Report a Synkro bug or suggest an improvement with diagnostic context. Guides Billing and usage Add funds and check your organization's balance and usage. Guides GitHub Connect GitHub to discover Rules from private repositories. Integrations CLI commands Find the current commands for setup, Rules, events, account, and recovery. Reference Supported agents Find the installed Synkro files and the checks that apply to each agent. Reference Troubleshooting Fix setup, sign-in, missing decisions, Rule, and approval problems. Reference No matching documentation Documentation Getting started What is Synkro? Quickstart Setup Setup checklist Install and verify Set up your agent Verify a decision Your first decision Core concepts How Synkro works Rules and Controls Rule outcomes Guides Rules Events Consent Feedback Billing and usage Integrations GitHub Reference CLI commands Supported agents Troubleshooting Request access Getting started What is Synkro? Quickstart Setup Setup checklist Install and verify Set up your agent Verify a decision Your first decision Core concepts How Synkro works Rules and Controls Rule outcomes Guides Rules Events Consent Feedback Billing and usage Integrations GitHub Reference CLI commands Supported agents Troubleshooting Getting started What is Synkro? Copy page Synkro is a package manager for agents. Its packages contain Rules for how agents use your software, tools, and services. Instead of yelling at your agent to fix the same thing over and over again, add your requirements to a Rule package. Reuse packages across projects, pin their versions, and add Rules for your own codebase. Packages live in Git and are managed through the Synkro CLI. A package might check that API errors are handled or require approval before deleting data. Synkro checks supported agent action
Thinking…

The quickstart requires access authorization ("Request access") and signing in — an approval-gated account. In other words, the hosted product requires an approved account and cannot be signed up for without human approval. Therefore, I should clearly communicate that I'm blocked at the signup step.

Also, for the pricing question, I'll fetch the billing/usage documentation. Let me grab the pricing details right away from the billing-and-usage page and the usage-measurement page.

timeout 15 curl -sL "https://docs.synkro.sh/guides/billing-and-usage" -o /tmp/b.html; timeout 15 curl -sL "https://synkro.sh/usage" -o /tmp/u.html; for f in /tmp/b.html /tmp/u.html; do echo "== $f"; python3 -c "import sys,re,html; t=open('$f').read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=html.unescape(re.sub(r'\s+',' ',t)); print(t[:2500])"; done
== /tmp/b.html
== /tmp/b.html
Not found
== /tmp/u.html
 404: Not Found 404: Not found Path: /usage
Thinking…

I need to find the actual URL for the billing and usage documentation by checking the links on the docs homepage.

timeout 15 curl -sL https://docs.synkro.sh | grep -oE 'href="[^"]+"' | sort -u | grep -iE 'billing|usage|quickstart|pricing'
href="/guides/billing"
href="/guides/billing"
href="/quickstart"
Thinking…

I need to investigate this further. Let me check the details.

timeout 15 curl -sL https://docs.synkro.sh/guides/billing | python3 -c "import sys,re,html; t=sys.stdin.read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=html.unescape(re.sub(r'\s+',' ',t)); i=t.find('Billing'); print(t[i:i+2500])"; echo ====QUICKSTART; timeout 15 curl -sL https://docs.synkro.sh/quickstart | python3 -c "import sys,re,html; t=sys.stdin.read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=html.unescape(re.sub(r'\s+',' ',t)); i=t.find('Quickstart'); print(t[i:i+3000])"
Billing and usage Search documentation ⌘ K Request access What is Synkro? A package manager for agents, with Rules for using your software. Getting started Quic
Billing and usage Search documentation ⌘ K Request access What is Synkro? A package manager for agents, with Rules for using your software. Getting started Quickstart Let your agent set up Synkro, create your first Rule, and verify an action. Getting started Setup checklist Check your account, installation, repository, and first agent decision. Setup Install and verify Install the CLI, sign in, and connect your agent. Setup Set up your agent Connect your agent and verify its first tool call. Setup Verify a decision Find the recorded decision for an agent action. Setup Your first decision Read your first agent decision and test a Rule. Setup How Synkro works Understand how Synkro applies Rules and records agent decisions. Core concepts Rules and Controls Choose repository Rules for actions and Controls for access restrictions. Core concepts Rule outcomes Understand when an action continues, needs approval, or must be changed. Core concepts Rules Add, test, update, and remove the Rules used by your repository. Guides Events Find recorded agent actions and decisions with the Synkro CLI. Guides Consent Review and approve an agent action before it runs. Guides Feedback Report a Synkro bug or suggest an improvement with diagnostic context. Guides Billing and usage Add funds and check your organization's balance and usage. Guides GitHub Connect GitHub to discover Rules from private repositories. Integrations CLI commands Find the current commands for setup, Rules, events, account, and recovery. Reference Supported agents Find the installed Synkro files and the checks that apply to each agent. Reference Troubleshooting Fix setup, sign-in, missing decisions, Rule, and approval problems. Reference No matching documentation Documentation Getting started What is Synkro? Quickstart Setup Setup checklist Install and verify Set up your agent Verify a decision Your first decision Core concepts How Synkro works Rules and Controls Rule outcomes Guides Rules Events Consent Feedback Billing and usage Integrations GitHub Reference CLI commands Supported agents Troubleshooting Request access Getting started What is Synkro? Quickstart Setup Setup checklist Install and verify Set up your agent Verify a decision Your first decision Core concepts How Synkro works Rules and Controls Rule outcomes Guides Rules Events Consent Feedback Billing and usage Integrations GitHub Reference CLI commands Supported agents Troubleshooting Guides Billing and usage Copy page Add funds, check your b
====QUICKSTART
Quickstart Search documentation ⌘ K Request access What is Synkro? A package manager for agents, with Rules for using your software. Getting started Quickstart Let your agent set up Synkro, create your first Rule, and verify an action. Getting started Setup checklist Check your account, installation, repository, and first agent decision. Setup Install and verify Install the CLI, sign in, and connect your agent. Setup Set up your agent Connect your agent and verify its first tool call. Setup Verify a decision Find the recorded decision for an agent action. Setup Your first decision Read your first agent decision and test a Rule. Setup How Synkro works Understand how Synkro applies Rules and records agent decisions. Core concepts Rules and Controls Choose repository Rules for actions and Controls for access restrictions. Core concepts Rule outcomes Understand when an action continues, needs approval, or must be changed. Core concepts Rules Add, test, update, and remove the Rules used by your repository. Guides Events Find recorded agent actions and decisions with the Synkro CLI. Guides Consent Review and approve an agent action before it runs. Guides Feedback Report a Synkro bug or suggest an improvement with diagnostic context. Guides Billing and usage Add funds and check your organization's balance and usage. Guides GitHub Connect GitHub to discover Rules from private repositories. Integrations CLI commands Find the current commands for setup, Rules, events, account, and recovery. Reference Supported agents Find the installed Synkro files and the checks that apply to each agent. Reference Troubleshooting Fix setup, sign-in, missing decisions, Rule, and approval problems. Reference No matching documentation Documentation Getting started What is Synkro? Quickstart Setup Setup checklist Install and verify Set up your agent Verify a decision Your first decision Core concepts How Synkro works Rules and Controls Rule outcomes Guides Rules Events Consent Feedback Billing and usage Integrations GitHub Reference CLI commands Supported agents Troubleshooting Request access Getting started What is Synkro? Quickstart Setup Setup checklist Install and verify Set up your agent Verify a decision Your first decision Core concepts How Synkro works Rules and Controls Rule outcomes Guides Rules Events Consent Feedback Billing and usage Integrations GitHub Reference CLI commands Supported agents Troubleshooting Getting started Quickstart Copy page Let your agent set up Synkro, create your first Rule, and verify an action. For the setup below, open a Git repository in Claude Code, Codex, Cursor or Google Antigravity on Apple Silicon macOS or supported Linux. Synkro is in public preview. If your agent isn't listed here, email team@synkro.sh and we can enable it for you or build a custom integration. Using an AI agent? Copy the prompt below into your agent's chat. It handles signup, installation and your first Rule. You claim your account and approve the Rule it propos
Thinking…

Let me read the continuation of the quickstart content and the actual content of the billing page (the part after "Copy page Add funds, check your b..."). I'll fetch the continuation of both.

timeout 15 curl -sL https://docs.synkro.sh/guides/billing | python3 -c "import sys,re,html; t=sys.stdin.read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=html.unescape(re.sub(r'\s+',' ',t)); i=t.rfind('Copy page'); print(t[i:i+3000])"; echo ====; timeout 15 curl -sL https://docs.synkro.sh/quickstart | python3 -c "import sys,re,html; t=sys.stdin.read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=html.unescape(re.sub(r'\s+',' ',t)); i=t.rfind('Copy page'); print(t[i:i+4000])"
Copy page Add funds, check your balance, and see what your organization has used. Synkro uses a prepaid organization balance. An organization owner manages paym
Copy page Add funds, check your balance, and see what your organization has used. Synkro uses a prepaid organization balance. An organization owner manages payments; everyone in the organization uses the same funds. Sandbox uses test cards, test payments and a $20 starter balance, separate from production funds. Use test cards only. Starter credit Complete account verification and save a test card during signup. Synkro adds the $20 starter credit once the saved card is confirmed, once per new organization. Check the credited balance with synkro account balance . Add funds Sign in to Synkro sandbox billing , choose Add funds , enter an amount within the displayed range, and complete checkout with a test card. Your test balance updates after confirmation. You can also open checkout from the CLI: synkro account pay That command opens checkout for the minimum amount. To choose an amount in US dollars: synkro account pay --amount 100 Review the amount and complete payment in checkout. Check balance and usage Run these commands from your signed-in CLI. An owner can view billing details with synkro account status ; organization members can check balance and usage: synkro account balance synkro account usage Usage shows decisions, charges, and token counts for the last 30 days. Change the grouping or date range: synkro account usage --weekly synkro account usage --monthly --from 09-01-26 --to 09-30-26 CLI dates use MM-DD-YY . The service uses UTC day boundaries and includes the end date. Add --json to an account command for structured output. JSON balance and charge fields ending in Microusd use millionths of a US dollar; checkout amountCents uses cents. If the balance runs out Run synkro account balance and synkro status . Enforcement pauses when the balance cannot cover a decision. An owner can add funds, then check status again. For other account or service errors, see Troubleshooting . Sandbox and production balances are separate. Check the environment shown before adding funds. What counts as usage A governed action can carry a base charge. For semantic checks, that base charge is included in the semantic-check charge. Use synkro account usage to see your organization's charges. Installing, reading status or events, and testing deterministic examples do not incur usage charges. synkro check bills semantic examples through your configured account service. A late decision is refunded, including its base charge; a balance reservation alone is not a final charge. Previous Feedback Next GitHub On this page Starter credit Add funds Check balance and usage If the balance runs out What counts as usage 
====
Copy page Let your agent set up Synkro, create your first Rule, and verify an action. For the setup below, open a Git repository in Claude Code, Codex, Cursor or Google Antigravity on Apple Silicon macOS or supported Linux. Synkro is in public preview. If your agent isn't listed here, email team@synkro.sh and we can enable it for you or build a custom integration. Using an AI agent? Copy the prompt below into your agent's chat. It handles signup, installation and your first Rule. You claim your account and approve the Rule it proposes. Let your agent handle setup Your agent handles setup. You verify your account and approve your first Rule. Sign up, set up this repository, and verify a first Rule with your agent. Copy prompt Set up Synkro for my agent and this repository. Use the latest released CLI, not a local source build. Follow https://docs.synkro.sh/quickstart and the steps below. Keep updates short. Stop only for missing account access, a required human sign-in or approval, or an error you cannot safely resolve. Start registration on my behalf and connect to my account after I claim it and approve the connection. You cannot claim the account or approve yourself. If I am already signed in on this installation, preserve it and ask whether to continue that setup or use a separate installation for your limited connection. This signup is for the sandbox. Set SYNKRO_WEB_AUTH_URL=https://app.sandbox.synkro.sh for every setup command and resumed session. Keep sandbox credentials separate from any production installation. Use test cards only; the $20 starter credit is a sandbox test balance, not production funds. Never enter a real card. If this prompt is pasted again after sign-in or a restart, inspect the current state and continue from the first incomplete step. Do not reinstall everything. Pause for me to verify my email, review the terms, approve the connection and save a test card on the returned Synkro page. Continue setup when those steps finish. The $20 starter credit is awarded after the saved card is confirmed. After installing or updating the CLI binary, check synkro onboard --help, synkro onboard claim --help and synkro onboard verify --help. Read https://app.sandbox.synkro.sh/auth.md and follow that guide for signup, connecting the agent, installation and scoped Rule verification. For an administrator-provided test service, use /auth.md on that approved App origin instead, keeping existing accounts and environments separate. If commands are still missing after updating, or the guide or service is unavailable, stop and report the version and error. Do not switch services or use my personal sign-in credentials to get past a restriction. A fresh install uses Synkro's hosted service. Add --daemon-url only for the verified service selected by account setup or supplied by the administrator. For a new account, after installing the CLI and checking for saved progress, run synkro onboard start --email EMAIL --json using the email I provide. This adds my email to the waitlist. Once the Synkro team approves my request, I can claim my account so you can continue setup. While the next action is review_application, use synkro onboard resume --wait-seconds 300 --json to check the saved request; do not submit it again. If I prefer to request access myself, give me https://synkro.sh/request-access and continue with that same email. Website and CLI requests join the same waitlist. 1. Identify the OS, architecture, current repository, and installed agent. Use git rev-parse --show-toplevel and git status --short. Ask which repository only if it is unclear. Check command -v synkro, synkro --version, synkro whoami --json, and synkro status --json when available. Missing commands are normal on a fresh machine. An approved Synkro account in an organization is required; a waitlist entry is not enough. 2. On Linux, prefer the verified direct download at https://docs.synkro.sh/onboarding/install#linux-without-homebrew. It installs into the u
Thinking…

Now the situation is clear:

Synkro (synkro.sh) is a hosted "package manager for agents"/control layer. Quickstart requirements:

  1. An approved Synkro account — signup goes through a waitlist ("review_application", team approval), and then a human needs to claim the account, verify email, agree to the terms of service, approve the connection, and save a test card.
  2. A supported agent environment (Claude Code, Codex, Cursor, Antigravity).

In other words, the quickstart has a hard human-in-the-loop gate: waitlist approval + human claiming/approval. I can't complete this on my own — I'm blocked. According to the user's instructions: "Let me know if you get blocked" and "If this product has no developer workflow you can act on, state that frankly and stop."

The hosted product has a developer workflow (CLI, docs), but it's gated behind waitlist approval and human account claiming — I can't proceed to actually building the example. Pricing can be described: prepaid organization balance, pay-per-checked-action (decision), semantic-check billing, $20 starter credit in sandbox, refunds for delayed decisions, no billing for install/status/deterministic tests.

Also note the ambiguity: there's an unrelated open-source library @synkro/core (workflow orchestrator, MIT, no pricing). Should mention it briefly. But per the user's framing ("hosted product", "pricing"), synkro.sh is the product in question.

Could I still "build a simple example"? I could install the CLI and maybe write an example rule TOML file, but without an approved account I can't sign in, and enforcement requires the hosted service. The instructions say to state frankly if blocked. I could also check whether the CLI install works without an account, but... the quickstart explicitly says "an approved Synkro account within an organization is required, and waitlist entry alone is not enough." Human approval required → blocked. State that frankly and stop, but provide the pricing info and manageability assessment, and optionally show what the example would look like (an example rule TOML based on the docs) — but keep it light. Actually, the instructions say "state that frankly and stop" if there's no developer workflow I can act on. A workflow exists, but it's gated behind human approval, which qualifies as "blocked." Report the blocker, stop, and don't build anything. As a preview, I might include a minimal example rule TOML from the docs. Let me lightly fetch the rules doc for an example. Keep it light — probably one quick fetch.

timeout 15 curl -sL https://docs.synkro.sh/concepts/rules | python3 -c "import sys,re,html; t=sys.stdin.read(); t=re.sub(r'<script.*?</script>','',t,flags=re.S); t=re.sub(r'<style.*?</style>','',t,flags=re.S); t=re.sub(r'<[^>]+>',' ',t); t=html.unescape(re.sub(r'\s+',' ',t)); i=t.rfind('Copy page'); print(t[i:i+1800])"
d
d
Thinking…

I need to investigate this further. Let me check the details.

timeout 15 curl -sL https://docs.synkro.sh | grep -oE 'href="/[^"]+"' | sort -u
href="/brand.css"
href="/brand.css"
href="/concepts/decisions"
href="/concepts/how-synkro-works"
href="/concepts/rules-and-controls"
href="/docs.css"
href="/first-decision"
href="/guides/billing"
href="/guides/consent"
href="/guides/events"
href="/guides/feedback"
href="/guides/rules"
href="/index.md"
href="/integrations/github"
href="/onboarding"
href="/onboarding/coding-agents"
href="/onboarding/install"
href="/onboarding/verify-events"
href="/parcel-favicon-16.png?v=bow-1"
href="/parcel-favicon-32.png?v=bow-1"
href="/parcel-favicon-64.png?v=bow-1"
href="/parcel-touch-icon.png?v=bow-1"
href="/quickstart"
href="/reference/cli"
href="/reference/supported-agents"
href="/troubleshooting"
Thinking…

Sufficient information has been obtained. The quickstart is gated by the waitlist. Following the instructions, I should clearly state the blocker and stop. Let me summarize:

  1. Which Synkro: synkro.sh (hosted version, "package manager for agents" / control layer). Also mention the unrelated OSS @synkro/core.
  2. Pricing: Prepaid balance for the organization; pay-per-check for agent actions (decisions); basic fee + semantic check fee; refunds for delayed decisions; installation/status/deterministic tests are free; $20 starter credit in sandbox after test card registration; usage can be checked via CLI.
  3. Manageability: Yes, there's a clean developer workflow that's easy for agents to handle (CLI, docs, auth.md designed for agents, JSON output) — however, signup requires manual waitlist approval + account claim/approval, and it can't be executed autonomously.
  4. Blocked: Yes — account required. Clearly state this and stop; don't create sample files.

Blocked — stopping here, as instructed. Summary of what I found:

Which "Synkro"

Two products share the name. The hosted one matching your framing ("hosted product, SDK/API, pricing") is synkro.sh — "the package manager for agents" / a control layer that checks agent actions (commands, file edits) against TOML Rules before they run, via a CLI (@synkro-sh/cli) backed by a hosted service. (The other is @synkro/core, an unrelated MIT open-source Redis/in-memory workflow orchestrator with no pricing at all — not a hosted product.)

How pricing works (synkro.sh)

  • Prepaid organization balance: an org owner adds funds; everyone in the org spends from the same balance.
  • You pay per checked action ("decision"): a governed action can carry a base charge; semantic (LLM-based) rule checks carry a semantic-check charge that includes the base charge.
  • Free: installing the CLI, reading status/events, and testing deterministic rule examples incur no charges. Late decisions are refunded; a balance reservation alone isn't a final charge.
  • Enforcement pauses if the balance can't cover a decision, until an owner tops up.
  • Sandbox: separate test environment with a one-time $20 starter credit after account verification + saving a test card; test cards only.
  • Usage is inspectable via CLI: synkro account balance, synkro account usage [--weekly|--monthly], --json (amounts in micro-USD / cents).

Will it be easy for me to manage?

The developer workflow itself looks very agent-friendly: docs are excellent, the CLI has --json output everywhere, and the quickstart is explicitly designed to be handed to a coding agent (there's even an auth.md written for agents). However, I cannot act on it autonomously: signup is gated behind a waitlist (synkro onboard start just joins it; "an approved Synkro account in an organization is required; a waitlist entry is not enough"), and a human must claim the account, verify email, accept terms, approve the agent connection, and save a test card. It's also in public preview and limited to specific agents/platforms.

Blocker

I can't build the example: every path to a working rule/decision requires an approved account plus human sign-in and approval steps — no API key, SDK-only mode, or anonymous sandbox exists. Per your instructions, I'm stating that plainly and stopping. No files were created and nothing long-running was started. If you get waitlist approval and claim the account, I can resume from the quickstart and wire up a first Rule in minutes.

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge