This site describes where Silc is going. The loop kernel ships today; some steps shown here are in development.

Loop engineering · open source

Declare the loop.

Silc picks the runtime.

Write one .silc file that scrapes, embeds, asks a model, gates and writes. The compiler bounds every run before it starts, routes each step to the engine built for it and replays the run after a crash instead of doing the work twice.

~/watch · silc
$ silc build main.silc
parsed · checked · routed · plan sha256:4c1f…9e07
loops (worst case per run, from static bounds):
UpstreamWatch schedule "0 7 * * 1-5" America/Chicago
model calls 120 · effects 41 (writes 40, notices 1) · approvals 0 · reads 40 · rows scanned 240
$ silc main.silc
kernel up · cpython (silclm, minilm-l6-v2) · bun /loops
UpstreamWatch run 812 replayed 31 steps from the event log, resumed at step 32
One loop, start to finish

Scrape, embed, ask, gate, write. One file, one loop.

Every weekday at seven, check each dependency's changelog, compare it with incidents you have already had, ask a local model whether this release puts you at risk, and open a ticket only when it does. Every step lives in the same loop.

main.silc · target syntaxTarget syntax
1contract Release { has Str $.version; has Str $.text; }
2contract Impact { has Str $.risk; has Str $.summary; }
3
4loop UpstreamWatch {
5 loop::flow(
6 loop::schedule(:cron("0 7 * * 1-5"), :tz("America/Chicago")),
7 loop::find(:as(deps), :from(Dependencies.list), :max(40)),
8
9 loop::each(:in($deps), :as(dep), :max(40),
10 loop::read(:as(release), :into(Release),
11 scrape::page(:url($dep.changelog), :select("article"))),
12
13 loop::let(:as(vec),
14 tensor::infer(:model("minilm-l6-v2"), :from($release.text))),
15 loop::find(:as(seen), :max(5),
16 :from(Incidents.nearest(:to($vec)))),
17
18 loop::ask(:as(impact), :into(Impact), :retry(2),
19 :from($release, $seen),
20 :prompt("Does {$dep.name} {$release.version} repeat any of these?"),
21 loop::otherwise(loop::skip(:reason("no grounded answer")))),
22
23 loop::gate(:that($impact.risk != "none"),
24 :reason("only real risk reaches a person"),
25 loop::otherwise(loop::skip(:reason("no risk")))),
26
27 loop::write(:to(Tickets.create),
28 :key("upgrade:{$dep.name}:{$release.version}"),
29 :value(Ticket.new(:title($impact.summary),
30 :risk($impact.risk))))
31 ),
32
33 loop::notify(:to("platform"), :text("Watch ran {$calendar.today}"),
34 :key("watch:{$calendar.today}"))
35 )
36}

Illustrative. This is the syntax Silc is heading toward; 0.7.0 cannot yet mix scrape, tensor and model steps in one loop.

silc build main.silc
$ silc build main.silc
✓ parsed ✓ types ✓ gates ✓ bounds
routing
scrape::page → bun static fetch
tensor::infer → cpython minilm-l6-v2 · cpu
loop::ask → cpython silclm · local
find · write → go sqlite · receipts
schedule · log → go loop kernel
loops (worst case per run, from static bounds):
UpstreamWatch schedule "0 7 * * 1-5"
America/Chicago
model calls 120
effects 41 (writes 40, notices 1)
approvals 0
reads 40
rows scanned 240
plan loop/plans/4c1f…9e07.json
120
model calls at most: 40 dependencies × (1 ask + 2 retries)
41
effects at most, each keyed so a retry never repeats one
0
unchecked effects: every model answer passes a gate first
Loop engineering

Guarantees the compiler can check before the loop ever runs.

A loop that runs on its own has to be safe on a bad day. Silc's rules are not conventions in a README; the compiler rejects a loop that breaks them.

loop_events · UpstreamWatch · run 812append-only
  1. 07:00:00triggerschedule "0 7 * * 1-5" America/Chicago
  2. 07:00:00pinplan sha256:4c1f…9e07 · pinned
  3. 07:00:01finddeps · 38 rows (max 40)
  4. 07:00:03readscrape::page · http-client 4.2.0 · recorded
  5. 07:00:03inferminilm-l6-v2 · 384 dims · recorded
  6. 07:00:05asksilclm → Impact { risk: high } · recorded
  7. 07:00:05gaterisk != none · pass
  8. 07:00:05writereceipt upgrade:http-client:4.2.0 · committed
  9. 07:00:06crashhost restarted
  10. 07:01:12replay31 events from log · 0 model calls repeated
  11. 07:01:12writereceipt upgrade:http-client:4.2.0 · exists, skipped
01

One trigger per loop

A cron schedule with a required IANA time zone, Run now, or a change to a declared resource. A loop never overlaps itself.

02

Gates fail closed

False or unknown stops the path. Every otherwise block ends in stop, fail or skip; nothing falls through.

03

Model output is checked

Values from a model can't reach a write or a notice until a gate inspects them or a person approves them.

04

Keyed effects, receipts

Every write and notice carries a key. The kernel reserves a receipt, acts, and commits in one transaction.

05

Static bounds

Every find and each has a max, every ask a bounded retry, every approval a deadline. The build prints the worst case.

06

Pinned to a plan hash

A run finishes on the exact plan it started on, even if you ship a new one halfway through.

07

Replay, not redo

Clock, reads, model answers and approvals land in an append-only log. A crash resumes from the log.

08

Fixed tool calls

The loop names every tool call and its arguments. The model reads what the loop fetched; it never picks tools.

Polyglot runtime

Silc picks the best runtime for the job. That is the power of Silc.

You write .silc and nothing else. The compiler reads every step, looks it up in a closed catalog of operations, and sends it to the engine whose strengths fit it, with a recorded reason for each choice. You never pick a language, and you never wire one to another.

how Silc chooses

  1. 01

    Read

    The compiler parses the loop, checks every type, gate and bound, and lists the operations it uses.

  2. 02

    Route

    Each operation maps to an engine through a strengths catalog: clocks and ledgers to Go, models and tensors to CPython, HTTP to Bun.

  3. 03

    Synthesize

    It writes the workers, the IPC glue and the state tables, then pins the plan by content hash.

  4. 04

    Supervise

    A supervisor starts only the engines the loop needs and keeps them alive as one co-located group.

main.silc → supervised worker group
main.silc→Rust compiler→plan sha256:4c1f…
Go
Go kernelschedulefindwriteevent logreceiptsreplay
Py
CPythonloop::asktensor::infertext::score
Bun
Bunscrape::page/loops inboxPOST /mcp
mmap slots · 512 × 16 KiBUDS control frames
Go 1.23.6CPython 3.12.12Bun 1.2.18Engines are pinned and checksum-verified into ~/.silc/runtimes on first use.
Go

Go kernel

Scheduler, run table, event log, receipts, replay and approval suspension, on the program's SQLite file.

Py

CPython

Model asks on a local, pinned silclm, embeddings with MiniLM, and the tensor and text work Python is best at.

Bun

Bun

Fetches pages, serves the approvals inbox and the MCP endpoint, and handles every HTTP edge.

IPC

Shared memory

Workers pass payloads through supervisor-owned mmap slots and wake each other with small Unix-socket frames.

Built-in steps

Scraping, tensors and models are loop steps, not services.

Reading the web, embedding text, scoring it and asking a model are part of the language. Put them anywhere in a loop, in any order, between a find and a gate, inside an each. The loop's guarantees cover every one of them.

loop::each · one dependencyloopscrapetensortextmodel
  1. 01

    find

    loop

  2. 02

    scrape::page

    scrape

  3. 03

    tensor::infer

    tensor

  4. 04

    find nearest

    loop

  5. 05

    text::score

    text

  6. 06

    loop::ask

    model

  7. 07

    gate

    loop

  8. 08

    write

    loop

In developmentToday each of these runs on its own or beside a loop. Mixing them freely inside one loop is the work Silc is building toward next.

web

Scraping

scrape::page, site, select and render read the web; fetched pages are recorded so a replay never refetches.

vec

Tensors

tensor::tokenize and tensor::infer turn text into 384-dimension MiniLM embeddings you can search and compare.

llm

Models

loop::ask runs on silclm, a pinned local model, and must answer in a typed contract you declared.

txt

Text

text::score ranks and filters text deterministically, so the model only sees what is worth its time.

Run it two ways

A command for today. A service for every day.

01

One-shot command

$ silc main.silc

With only manual triggers, the program is a command. It runs every loop once, narrates each step on stderr, prints notices on stdout and exits non-zero if a run failed. Put it in CI or a cron of your own.

  • Finishes any run a crash left behind
  • Same receipts and replay rules
  • Only the engines it needs start
02

Service with an inbox

$ silc main.silc # schedules + /loops

Add a schedule and Silc serves a /loops inbox: pending approvals, Run now for every loop, recent runs and notices. Approvals suspend the run; the decision is logged and replayed.

  • Approve or decline by name
  • Run a scheduled loop off schedule
  • Runs and notices readable through /api
MCPPOST /mcp

Every loop is an MCP tool

Silc synthesizes an MCP server at POST /mcp. Each manual or scheduled loop becomes a tool, so another system can start a run without learning your stack. The tool list is covered by the plan hash and printed by silc build.

curl -s localhost:18088/mcp \
  -H "Authorization: Bearer $SILC_MCP_TOKEN" \
  -d '{"method":"tools/call",
       "params":{"name":"upstream_watch_run"}}'
Quick start

Build from source and read your first cost report.

Silc builds with the Rust toolchain pinned in the repository. The first run provisions the pinned engines for you.

  1. 01Clone

    $ git clone https://github.com/thoughtpivot/silc && cd silc
  2. 02Install the compiler

    $ cargo install --path crates/silc --force
  3. 03Open the loop example

    $ cd examples/core/mcpLoopApp
  4. 04Check bounds and cost

    $ silc build main.silc
  5. 05Run it once

    $ silc main.silc
FAQ

Straight answers.

Does Silc do all of this today?

Not all of it. This site is a design document for where Silc is going. The loop kernel ships today: triggers, fail-closed gates, checked model output, keyed receipts, static bounds, pinned plans, replay, the /loops inbox and the MCP endpoint. Mixing scraping, tensor and model steps freely inside one loop is in development, and code marked as target syntax will not compile on 0.7.0 yet.

Is a Silc loop an agent?

No. A loop names every tool call and its arguments. The model reads what the loop fetched and answers in a typed contract, so every read, its cost and its replay are known at build time.

Do I write Go, Python or TypeScript?

No. You write .silc. The compiler chooses an engine for each step from a catalog of engine strengths and records why. Polyglot means Silc uses several runtimes, not that you have to.

Where does the model run?

Locally. loop::ask runs on silclm, a pinned Llama 3.2 3B Instruct model served by the CPython worker. Embeddings use a pinned MiniLM model on the CPU.

What happens when the host crashes mid-run?

The run resumes on the plan it started with. Every nondeterministic input is in the event log, so Silc replays it instead of asking the model or the web again, and keyed receipts stop any effect from happening twice.

How do I install it?

Build from source with cargo install --path crates/silc from a clone of the repository. Silc is pre-1.0 and follows SemVer 0.x.