#General learning

1 messages · Page 1 of 1 (latest)

viral ridgeBOT
#

A good mental model is a layer cake:

  1. Gateway (daemon) = the OS / “app server”
  • One long‑lived process that stays connected to chat surfaces (Discord/Telegram/WhatsApp/etc).
  • Owns sessions, routing, auth, and the tool RPC surface.
  • Also brokers connections from Control UI/CLI and from Nodes over WebSocket.
    Docs: https://docs.openclaw.ai/concepts/architecture
  1. Agent = the “program” (persona + policies + model)
  1. Tools = typed capabilities (the “syscalls”)
  • Tools are function calls the model can invoke (browser, web_fetch, message, cron, nodes, exec, etc).
  • Tools are implemented by OpenClaw core or by plugins, and are governed by allow/deny policy.
  • Key distinction: tools are real capabilities. If something isn’t a tool, the model can’t “do it” except by talking.
#

Docs: https://docs.openclaw.ai/tools

  1. Skills = “how to use tools” packaged as instructions
  1. Plugins = code extensions (how you add new tools / channels / commands)
  • If you want custom tooling in the “real” sense (new function calls, new RPC methods, new chat surface, etc), that’s a plugin.
  • Plugins can register:
    • new agent tools
    • new messaging channels
    • CLI commands, background services, HTTP handlers
    • and they can ship skills alongside the tools (common pattern).
      Docs: https://docs.openclaw.ai/tools/plugin
lament hatch
#

There seem to be overlap and cross connections. i would think that skills contain tools. But it looks like agents can call tools directly as well. Also skills and plugins seem to be about the same thing.

viral ridgeBOT
#
  1. Nodes = “remote hands” (extra hardware + permissions)
  • A paired macOS/iOS/Android/headless node can do device-y things (camera, screen record, notifications, location, run commands).
  • Conceptually: tools can execute on the gateway host or be routed to a node.
    Docs: https://docs.openclaw.ai/nodes

“What goes where?” (decision guide)

Put it in a Skill when…

  • You can already do the job with existing tools (browser/web_fetch/message/cron/exec/etc)
  • You mainly need a repeatable workflow + prompting discipline + safety checks
  • You want something you can iterate on fast (Markdown-only)

Put it in a Plugin (+ Tool) when…

  • You need a new typed function (e.g. jira.searchIssues, linear.createTicket, my_db.query)
  • You want structured inputs/outputs so the model doesn’t have to “compose curl commands”
#
  • You want reliability across models (tools tend to be more robust than “run a shell script with user text”)

Put it in a Node integration when…

  • The action must happen on a specific device (camera/screen, a desktop app automation, local-only network access, etc.)

Quick example

“I want a custom integration with my internal API.”

  • Skill-only approach: a skill that says “use web_fetch/exec to call the API and format the result”
    • fastest to prototype, but can be brittle (auth handling, error parsing, injection risk).
  • Plugin+tool approach: implement internal_api tool that returns clean JSON; ship a skill that teaches the agent when to call it.
    • more upfront work, much more reliable long-term.
#

If you tell me what kind of “custom tooling” you mean (call an HTTP API? run a local CLI? add a new chat surface? database access?) and where it needs to run (gateway host vs node), I can point you to the cleanest extension path and a minimal skeleton.

lament hatch
#

I'll want to have an agent that I can delegate a react native task to. I also have a golang api. Also a postgres db and maestro automation. I want to run a dev for front end, dev for back end, test case qa, and funtional qa. I'm trying to figure out how to orestrate this. Most skills are generalized and I want to make specialized ones.