Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
schpet avatar

Restate

schpet/toolbox

  • 9 installs
  • 5 repo stars
  • Updated June 1, 2026
  • schpet/toolbox

Helps with ai & agent building tasks.

About

restate is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.

  • restate
  • AI & Agent Building
  • AI-coding skill

Restate by the numbers

  • 9 all-time installs (skills.sh)
  • Ranked #12,152 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/schpet/toolbox --skill restate

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs9
repo stars★ 5
Last updatedJune 1, 2026
Repositoryschpet/toolbox ↗

What it does

Helps with ai & agent building tasks.

Files

SKILL.mdMarkdownGitHub ↗

Restate Durable Execution Framework

Restate is a durable execution framework that makes applications resilient to failures. Use this skill when building:

  • Durable workflows with automatic retries
  • Services with persisted state (Virtual Objects)
  • Microservice orchestration with transactional guarantees
  • Event processing with exactly-once semantics
  • Long-running tasks that survive crashes

When to Use Restate

Use Restate when:

  • Building workflows that must complete despite failures
  • Need automatic retry and recovery without manual retry logic
  • Building stateful services (shopping carts, user sessions, payment processing)
  • Orchestrating multiple services with saga/compensation patterns
  • Processing events with exactly-once delivery guarantees
  • Scheduling durable timers and cron jobs

Core Concepts

Service Types

Restate supports three service types:

1. Services - Stateless handlers with durable execution

  • Use for: microservice orchestration, sagas, idempotent requests

2. Virtual Objects - Stateful handlers with K/V state isolated per key

  • Use for: entities (shopping cart), state machines, actors, stateful event processing
  • Only one handler runs at a time per object key (consistency guarantee)

3. Workflows - Special Virtual Objects where run handler executes exactly once

  • Use for: order processing, human-in-the-loop, long-running provisioning

See Services Concepts for detailed comparison.

Durable Building Blocks

Restate provides these building blocks through the SDK context:

  • Journaled actions (ctx.run()) - Persist results of side effects
  • State (ctx.get/set/clear) - K/V state for Virtual Objects
  • Timers (ctx.sleep()) - Durable sleep that survives restarts
  • Service calls (ctx.serviceClient()) - RPC with automatic retries
  • Awakeables - Wait for external events/signals

See Durable Building Blocks.

TypeScript SDK Quick Reference

Installation

npm install @restatedev/restate-sdk

Basic Service

import * as restate from "@restatedev/restate-sdk";

const myService = restate.service({
  name: "MyService",
  handlers: {
    greet: async (ctx: restate.Context, name: string) => {
      return "Hello, " + name + "!";
    },
  },
});

restate.endpoint().bind(myService).listen(9080);

Virtual Object (Stateful)

const counter = restate.object({
  name: "Counter",
  handlers: {
    add: async (ctx: restate.ObjectContext, value: number) => {
      const current = (await ctx.get<number>("count")) ?? 0;
      ctx.set("count", current + value);
      return current + value;
    },
    get: restate.handlers.object.shared(
      async (ctx: restate.ObjectSharedContext) => {
        return (await ctx.get<number>("count")) ?? 0;
      }
    ),
  },
});

Workflow

const paymentWorkflow = restate.workflow({
  name: "PaymentWorkflow",
  handlers: {
    run: async (ctx: restate.WorkflowContext, payment: Payment) => {
      // Step 1: Reserve funds
      const reservation = await ctx.run("reserve", () =>
        reserveFunds(payment)
      );

      // Step 2: Wait for approval (awakeable)
      const approved = await ctx.promise<boolean>("approval");
      if (!approved) {
        await ctx.run("cancel", () => cancelReservation(reservation));
        return { status: "cancelled" };
      }

      // Step 3: Complete payment
      await ctx.run("complete", () => completePayment(reservation));
      return { status: "completed" };
    },

    approve: async (ctx: restate.WorkflowSharedContext) => {
      ctx.promise<boolean>("approval").resolve(true);
    },

    reject: async (ctx: restate.WorkflowSharedContext) => {
      ctx.promise<boolean>("approval").resolve(false);
    },
  },
});

Key SDK Patterns

// Journaled action - result persisted, replayed on retry
const result = await ctx.run("action-name", async () => {
  return await callExternalApi();
});

// Durable timer - survives restarts
await ctx.sleep(60_000); // 60 seconds

// Call another service
const client = ctx.serviceClient(OtherService);
const response = await client.handler(input);

// Async call (fire and forget)
ctx.serviceSendClient(OtherService).handler(input);

// Delayed call
ctx.serviceSendClient(OtherService, { delay: 60_000 }).handler(input);

// Awakeable - wait for external signal
const { id, promise } = ctx.awakeable<string>();
// Give `id` to external system, then:
const result = await promise;

// Random (deterministic)
const value = ctx.rand.random();
const uuid = ctx.rand.uuidv4();

Running Locally

1. Start Restate server:

npx @restatedev/restate-server

2. Run your service:

npx ts-node src/app.ts

3. Register service with Restate:

npx @restatedev/restate deployments register http://localhost:9080

4. Invoke handlers via HTTP:

# Service handler
curl localhost:8080/MyService/greet -H 'content-type: application/json' -d '"World"'

# Virtual Object handler (with key)
curl localhost:8080/Counter/user123/add -H 'content-type: application/json' -d '5'

# Start workflow
curl localhost:8080/PaymentWorkflow/order-456/run -H 'content-type: application/json' -d '{"amount": 100}'

Documentation References

Concepts

  • Services - Service types and use cases
  • Invocations - How invocations work
  • Durable Execution - Execution guarantees
  • Durable Building Blocks - SDK primitives

TypeScript SDK

  • Overview - SDK setup and service definitions
  • State - K/V state management
  • Journaling Results - Side effects and ctx.run()
  • Durable Timers - Sleep and scheduling
  • Service Communication - Calling other services
  • Awakeables - External events
  • Workflows - Workflow implementation
  • Error Handling - Error patterns
  • Serving - Running services
  • Testing - Testing strategies
  • Clients - Client SDK

Guides

  • Error Handling - Comprehensive error handling
  • Sagas - Saga pattern with compensations
  • Cron Jobs - Scheduled tasks
  • Parallelizing Work - Fan-out patterns
  • Databases - Database integration
  • Lambda Deployment - AWS Lambda deployment

Use Cases

  • Workflows
  • Async Tasks
  • Event Processing
  • Microservice Orchestration

Operations

  • HTTP Invocation
  • Service Registration
  • Versioning
  • Architecture

Important Guidelines

1. Side effects must be wrapped in `ctx.run()` - External calls, random values, timestamps must go through the context to be journaled and replayed correctly.

2. State access only in Virtual Objects/Workflows - Plain Services don't have state access.

3. Handlers must be deterministic - Same inputs should produce same outputs. Use ctx.rand for randomness.

4. One handler per Virtual Object key at a time - Restate ensures consistency by queuing concurrent requests to the same key.

5. Workflows `run` handler executes exactly once - Use other handlers to query/signal the workflow.

6. Register services after code changes - Run restate deployments register to update handler definitions.

--- Generated from Restate documentation. Run `scripts/sync-docs.sh` to update.

License

The content in the references/ directory is derived from the Restate documentation and TypeScript SDK.

Related skills

mattpocockSetup Matt Pocock SkillsScaffold the per-repo configuration that Matt Pocock’s engineering agent skills rely on so they understand the issue tracker, triage labels, and domain documentation la495k196kopen.feishu.cnLark AppsConnect Claude, Cursor or custom agents directly to Lark (Feishu) for messaging, document automation, approval workflows and enterprise data access.402kjuliusbrusseeCavemanSlash token usage by roughly 75% while keeping every technical detail intact when working with Claude Code, Cursor or similar agents.391k94.7klarksuiteLark Skill MakerQuickly turn any Lark/Feishu OpenAPI call or multi-step workflow into a reusable agent skill with its own SKILL.md.386k16kxixu-meRunning Claude Code Via Litellm CopilotRun Claude Code at a fraction of the cost by routing requests through LiteLLM to the GitHub Copilot Chat API.270k72runcomfy-comCodex PetGenerate a complete Codex Pet spritesheet and metadata from one reference image without needing an OpenAI key or Codex Pro.246k10
AI & Agent Buildingagents
Browse by category
AI & AgentsFrontend & DesignBackend & DataDev ToolsAutomationTesting & ReviewSecurityMonitoring & CloudDocs & Planning
Design & frontend
Design systemsAnimation & motionAccessibility (a11y)CSS & TailwindUI designUXDesign to codeshadcn/uiLanding pagesBest design skills
Most searched skills
find-skillscavemanfrontend-designbrainstormingsystematic-debuggingstop-slopemil-design-engui-ux-pro-maxkarpathy-guidelinesweb-design-guidelinesreact-best-practicesgrill-meimprovemicrosoft-foundryagent-browser
Browse all listings
All agent skillsAll MCP serversAll marketplacesAll plugins

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.