Caedos
GitHub ★ Start →

PRODUCT

Everything it does. And what it doesn't, yet.

Processes and triggers.
Run on a schedule, on an incoming webhook (optional HMAC-SHA256 verification), on a Relay signal, or only when you press Run. A process never overlaps itself; a slow tick delays the next one instead of stacking.
The catalog: 27 primitives.

Sources

  • http_fetch
  • rest_api pagination, list-then-detail
  • rss_read
  • dom_scrape CSS selectors, static HTML
  • mcp_source
  • webhook_receive
  • signal_subscribe

Transforms

  • extract
  • filter
  • count_matches
  • aggregate
  • compute
  • sort
  • sample
  • format

Fast paths

  • fast_path_diff
  • fast_path_threshold
  • fast_path_regex
  • fast_path_new_items
  • fast_path_always

Reasoning

  • llm_reason

Actions

  • notify_webhook ●
  • post_to_api ●
  • mcp_action ●
  • publish_signal
  • publish_page

State

  • write_state

= touches the outside world (leashed by default)

Numbers don't go through a model.
Arithmetic has its own small expression language (+ − × ÷ %, min, max, round…), and errors are loud, never zero. The rule the handbook gives your AI: never ask a model for a number.
Models, your key.
Anthropic (default), OpenAI or xAI. Switch providers without a restart. Pick a tier per process: economy, standard or premium. Caedos escalates within the tier if an answer doesn't parse. Responses are cached.
The leash and policy.
Per-process approval queue. Workspace policy: default leash, a daily dollar ceiling and a daily tick ceiling every process inherits (they only tighten), allowed outbound domains, a monthly budget warning.
Shadow and replay.
Rehearse a new synth against the live world with actions muted, or re-run yesterday's tick against today's config.
Traces and provenance.
Origin, mode, config version, cost, warnings, per tick. Every config change is a version you can revert, labeled by who made it: you, or the repair loop.
The Relay.
Topic-based signals between processes (team.* wildcards). A live wiring graph.
The control room.
Process table, journals, approvals, Live Feed, Relay view, connections, knowledge, settings, and a daily "Today" summary: "Every check came back quiet."
Connections.
MCP servers over Streamable HTTP or stdio (a catalog of common servers plus the official MCP registry), REST APIs with endpoint inspection, and verified outbound channels (webhook, MCP tool or REST). Health is checked continuously; a broken connection tells you before a process fails on it.
Healing and autopsy.
A circuit breaker, bounded repair, and a written autopsy when it gives up.
Sharing.
Publish a read-only journal at a secret link, zero JavaScript, with RSS. A process can maintain its own page or feed with publish_page. Secrets are rejected from anything public at deploy.
Cost.
Per tick, per process per day, fleet today, a monthly estimate before deploy, and a daily digest to your webhook.
Portability.
Export the whole workspace (processes, memory, channels, knowledge, policy, connections), minus secrets. Import it anywhere.
Chaos mode.
Inject faults on purpose and watch detection and repair work, with a banner you can't miss.
Start → Security →

FAQ

Which models does it support?

Anthropic (default), OpenAI and xAI. Pick a tier per process (economy, standard, premium), and change models in Settings without restarting.

What can it connect to?

HTTP and REST APIs, RSS, static web pages via CSS selectors, webhooks in, MCP servers (HTTP or stdio), and outbound webhooks, APIs and MCP tools. It also connects to itself via the Relay.

Can it read JavaScript-heavy sites?

Not directly: dom_scrape reads static HTML. You can route through a browser MCP server such as Puppeteer, or point at the site's JSON or RSS feed.

How is it different from Zapier or n8n?

They run the workflow you drew, and are great at the last mile. Caedos runs a synth your AI wrote, calls a model only on change, and holds outbound actions for approval. They work well together: the Outbound courier blueprint hands drafts to your n8n or Zapier webhook.

How is it different from scheduled tasks in ChatGPT or Claude?

Those run a model every time they fire. Caedos runs deterministic checks and calls a model only when something changed, keeps memory between runs, and records every tick where you can read it.

What if I stop using it?

Export your workspace: processes, memory, channels, knowledge, policy and connections, without secrets. Your configs are plain data.