Skip to content
Skills Library
Programming · Automation

switch-operator-engine

/switch-operator-engine

Boot any of the 5 polyglot smooth-operator LocalServer implementations (rust / go / ts / python / dotnet) via `th operator serve --lang <x>` so Big Smooth can dogfood each engine over the shared WS protocol. Use when the user asks to "switch operator engines", "run the go/ts/python/dotnet server", "dogfood the polyglot operator", "compare engines", or when you need a LocalServer of a specific language up to drive with the bench harness.

Repository
smooth ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Boot any of the 5 polyglot smooth-operator LocalServer implementations (rust / go / ts / python / dotnet) via `th operator serve --lang <x>` so Big Smooth can dogfood each engine over the shared WS protocol. Use when the user asks to "switch operator engines", "run the go/ts/python/dotnet server", "dogfood the polyglot operator", "compare engines", or when you need a LocalServer of a specific language up to drive with the bench harness.

Triggers from the description

switch operator enginesrun the go/ts/python/dotnet serverdogfood the polyglot operatorcompare engines
Original author description

Boot any of the 5 polyglot smooth-operator LocalServer implementations (rust / go / ts / python / dotnet) via `th operator serve --lang <x>` so Big Smooth can dogfood each engine over the shared WS protocol. Use when the user asks to "switch operator engines", "run the go/ts/python/dotnet server", "dogfood the polyglot operator", "compare engines", or when you need a LocalServer of a specific language up to drive with the bench harness.

How it works

  1. The command
  2. Per-engine notes (the ones that bite)
  3. How to run one (it blocks)
  4. When NOT to use this
Original SKILL.md headings · 61 lines, 442 words
SKILL.md preview
---
name: switch-operator-engine
description: Boot any of the 5 polyglot smooth-operator LocalServer implementations (rust / go / ts / python / dotnet) via `th operator serve --lang <x>` so Big Smooth can dogfood each engine over the shared WS protocol. Use when the user asks to "switch operator engines", "run the go/ts/python/dotnet server", "dogfood the polyglot operator", "compare engines", or when you need a LocalServer of a specific language up to drive with the bench harness.
---

# switch-operator-engine — dogfood each polyglot smooth-operator server

The smooth-operator LocalServer has five implementations that all speak the same
WS protocol: **rust, go, ts, python, dotnet**. `th operator serve` boots any one
of them behind a uniform env contract, so Big Smooth (and the bench harness) can
drive each engine identically and compare behavior. Pearl th-3f46fd.

The servers live in the sibling **`smooth-operator`** repo (default
`~/dev/smooai/smooth-operator`; override with `SMOOTH_OPERATOR_REPO`). This is a
dev/dogfooding tool — it spawns a server process in the foreground and blocks.

## The command

```bash
th operator serve --lang <rust|go|ts|python|dotnet> [--port <n>]
th operator serve --help          # per-engine caveats, self-documenting
```

- **Default port** is `8799`.
- Every engine inherits the shared env contract from your shell:
  `SMOOAI_GATEWAY_URL`, `SMOOAI_GATEWAY_KEY`, `SMOOTH_PERSONA`, and
  `SMOOAI_MODEL` (defaults to `deepseek-v4-flash`). No gateway key → it still
  boots and turns errors cleanly.
- The launcher sets the correct per-engine bind var from `--port` for you.

## Per-engine notes (the ones that bite)

| `--lang` | What runs                                 | Caveat                                                                                                                           |
| -------- | ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `rust`   | `th daemon`                               | The only runnable Rust LocalServer — it's the daemon, so it carries the daemon's narc/storage/persona extras, not a bare engine. |
| `go`     | `go run ./cmd/serve`                      | Needs Go toolchain.                                                                                                              |
| `ts`     | `node dist/main.js`                       | Auto-builds (`pnpm install && pnpm build`) on first run if `dist/main.js` is missing.                                            |
| `python` | `uv run python -m smooth_operator_server` | Bind is **hardcoded 127.0.0.1:8787 upstream** — `--port` is ignored (the CLI warns you). Runs `uv sync` first.                   |
| `dotnet` | `dotnet run`                              | Needs .NET SDK.                                                                                                                  |

## How to run one (it blocks)

`th operator serve` runs in the foreground. To keep working while it serves,
launch it in the background / a separate pane and drive it over WS on the bound
port, e.g.:

```bash
# boot the Go engine on a spare port, in the background
th operator serve --lang go --port 8801 &
# ...drive ws://127.0.0.1:8801 with the bench harness / a WS client...
# stop it when done
kill %1
```

For a build-and-boot smoke of **all five** at once (each on its own port, PASS =
the port accepts TCP), the repo's `scripts/operator-serve.sh smoke` still does
that — `th operator serve` is the single-engine, discoverable front door.

## When NOT to use this

- To run the production/daemon Big Smooth for real work, use `th up` / `th
daemon` directly — this skill is for _comparing engines_, not daily driving.
- If the sibling `smooth-operator` repo isn't checked out, `th operator serve`
  errors with the expected path — clone it or set `SMOOTH_OPERATOR_REPO`.

Versions

The database has no other skills named switch-operator-engine.

Database snapshot: 13.11.2026 · package version 39384d5ec94a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 86dogfood-python
    Use when doing exploratory QA of Python apps by real execution.
  • 98polyglot-test-agent
    Generates comprehensive, workable unit tests for any programming language using a multi-agent pipeline. Use when asked to generate tests, write unit tests, improve test coverage, add test coverage, create test files, or test a codebase. Supports C#, TypeScript, JavaScript,…
  • 100dogfood
    系统性地探索和测试 Web 应用,发现缺陷、UX 问题及其他问题。当被要求“dogfood”、“QA”、“探索性测试”、“发现问题”、“缺陷排查”、“测试此应用/站点/平台”,或审查 Web 应用质量时使用。产出结构化报告,附带完整复现证据——每个问题都有分步截图、复现视频和详细复现步骤——可直接交给相关团队。
  • 100create-lang-dev-skill
    Create a language-specific development skill by mining PR reviews, codebase conventions, build system patterns, and team documentation. Use when the user wants to create a new lang-dev skill (e.g., rust-dev, go-dev, python-dev) for their project.
  • 96playwright-dotnet
    Playwright .NET test generation instructions Triggers on: **
  • 100smooth-operator
    Drive the user's Smoo AI org Smooth Operator from the CLI via `smoo api smooth-operator chat` — draft/send email, create/search CRM contacts, generate templates, query analytics, search the knowledge base. Use when the user asks for an org-level action ("email this lead", "add a…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.