Back to goldclaw.ai

Documentation

Everything from quick starts to deep architectural references. Includes sections for Erlang/Elixir devs AND programmers from other ecosystems.

SOS.Support

Live Demo

Live production deployment for Wholesale Computers and Technology. Handles tech support and sales calls 24/7 via goldclaw's markdown-compiled voice pipeline. 12,847 calls handled, 340ms avg response, 47 days uptime.

"We went from spending $12K/month on after-hours call center staff to running goldclaw 24/7 with three markdown files. Customers can't tell the difference -- actually, response times are faster now."

Wholesale Computers and Technology -- Operations Manager

Procedures define the vocabulary of your running system. Actions produce side effects, Queries are pure functions. Each maps a symbolic name to an Elixir module function.

The procedure binding layer creates clean separation between intent and implementation. Change Say from Groq TTS to ElevenLabs by editing one line. Add new actions like SendSMS without touching core workflow code. Each procedure compiles to a module with a well-defined behaviour. Actions implement `@callback invoke(context, params) :: :ok | {:error, term}`. Queries implement `@callback invoke(context) :: {:ok, result}`.
procedures.md
# System Procedures

## Actions (Side Effects)

### Say
Speak text to the user.
**Implementation**: `NanobotPlugin.Actions.say/2`
**Params**: `text` (string)
**Runtime**: Groq TTS | ElevenLabs (hot-swap)
**Resample**: 24kHz -> 16kHz
**Cache**: common phrases pre-cached on boot

### Execute
Run a shell command in the workspace.
**Implementation**: `NanobotPlugin.Actions.execute/2`
**Params**: `command` (string)
**Sandbox**: yes | **Timeout**: 30s

## Queries (Pure Functions)

### Analyze
Analyze text for intent/sentiment.
**Implementation**: `NanobotPlugin.Queries.analyze/1`
**Returns**: `intent` (atom), `sentiment` (float)
**Model**: fine-tuned classifier

Two Kinds of Programmer Walk Into a Bar...

Erlang / Elixir

You Already Know This

If you know OTP, goldclaw is home. WORKFLOW.md compiles to gen_statem modules. PROCEDURES.md compiles to behaviour implementations. MODULES.md is your supervision tree.

Each state in your workflow becomes a handle_event/4 clause. Triggers become guard clauses. Transitions are {:next_state, atom(), data}. The MainBus is a gen_event manager.

You can drop down to raw Elixir at any point. Write a custom procedure, register it in PROCEDURES.md, done. The markdown is sugar, not a cage.

Key insight: goldrush compiles event queries to native BEAM modules for O(1) dispatch. goldclaw adds the markdown layer on top. Same performance, better DX.

Node / Python / Go / etc.

Your Language is Reinventing the Wheel

Every "new" event streaming framework in JS/Python/Go is poorly reimplementing ideas that Erlang solved in the 1980s. The BEAM VM has been running telecom infrastructure for 30+ years.

Node.js has a single-threaded event loop. Python has the GIL. Go has goroutines but lacks supervision and fault isolation. The BEAM runs millions of lightweight processes with preemptive scheduling and per-process GC.

Want hot-reload? BEAM does it natively -- swap modules while the system runs. Want fault tolerance? Every process is supervised. Want concurrency? Millions of processes, no shared state.

The good news: You don't need to learn Erlang. Write markdown. goldclaw compiles it to BEAM bytecode. You get 30 years of telecom engineering for free.

goldclaw doesn't ask you to rewrite anything. Start with three markdown files. As you grow, drop into Elixir for custom procedures.

What SOS.Support Runs

24/7 AI voice support
Intent classification for routing
LLM-powered free-form chat
Screen sharing via session codes
TTS with 24kHz to 16kHz resampling
Pre-cached common phrases
Self-healing architecture
Zero manual intervention