Menschen lesen die Seite.
Agenten lesen die Quelle.

Was Sie damit bauen

Ein KI-Agenten-Framework und eine Programmiersprache, in einer Binärdatei.

Alles, was eine agentische Anwendung braucht, steckt in der Sprache, nicht in einem obendrauf geklebten Framework: LLM-Aufrufe, Werkzeugnutzung, Gedächtnis, menschliche Freigabe, Multi-Agenten-Orchestrierung, ein Produktionsserver und das Sicherheitsmodell. Dieselbe Sprache baut deshalb auch die API, die Website, den Cron-Job und die CLI rund um den Agenten.

Eine Datei

Das ganze Backend, mit seinen Berechtigungen obenauf.

Ein Synsema-Programm beginnt damit, zu deklarieren, was es anfassen darf. Alles unter dieser Zeile läuft darin: die Routen, die Datenbank, die Secrets, das Modell. Beide Dateien unten parsen und laufen genau so.

-- A bookshop API. The `require` lines are the whole permission
-- surface: a port, one database file, one secret. Nothing else.
intent: "public read API; writes need the staff token"

require serve(8080)
require db("./shop.db")
require secret("API_TOKEN")

task check_token(token)
    let want be hmac_sha256("staff", token)
    when verify_hmac("staff", want, secret("API_TOKEN"))
        give {"role": "staff"}
    give nothing

serve on 8080
    auth with check_token
    rate_limit 120 per minute

    route "GET /books"
        give paged("SELECT id, title, price FROM books")

    route "POST /books" requires auth
        expect body {title: text, price: number}
        let b be json of request
        sql_exec("INSERT INTO books (title, price) VALUES (?, ?)",
                 [b.title, b.price])
        give created(b)

    route "GET /about"
        let doc be page([heading(1, "Bookshop"),
                         prose("HTML or Markdown, one route.")],
                        {"title": "Bookshop"})
        give content(doc)

-- An agent that triages support tickets. The model decides;
-- a human approves refunds; the API key is a sealed secret.
intent: "triage open tickets; refunds wait for a human"

require llm
require net("api.example.com")
require secret("SUPPORT_TOKEN")

let api be "https://api.example.com"
let auth be {"Authorization": bearer(secret("SUPPORT_TOKEN"))}
let r be http_get(api + "/tickets?open=1", auth)
let tickets be json_decode(body of r)

each t in tickets
    let msg be t["text"]
    let kind be decide between ["bug", "billing", "other"] given msg
    when kind == "billing"
        let amount be analyze msg for "the amount to refund"
        let who be t["customer"]
        approve "Refund " + text(amount) + " to " + who + "?" within 1h
    otherwise
        let reply be generate "a short, kind answer" given msg
        let url be api + "/tickets/" + t["id"] + "/reply"
        http_post(url, {"text": reply}, auth)

• require ist die Berechtigungsoberfläche. Ein Port, eine Datenbankdatei, ein Secret. Ein fetch zu jedem anderen Host wird vom Interpreter verweigert.
• Auth und Validierung sind Deklarationen. auth with benennt die Task, die sagt, wer ein Token ist; expect body weist eine falsche Nutzlast mit einem 400 ab, das das Feld nennt.
• Eine Route, jeder Leser. content() antwortet Browsern mit HTML und Agenten mit Markdown oder JSON; paged() paginiert große Ergebnisse für Sie.
• Das Modell ist ein Primitiv. decide liefert eine der Optionen oder versucht es erneut; analyze und generate sind typisiert, keine von Hand zusammengeklebten Prompt-Strings.
• Ein Mensch ist auch ein Primitiv. approve … within 1h wartet auf eine echte Person; ist niemand da, lehnt es ab.
• Secrets materialisieren sich nie. Der Schlüssel reist versiegelt bis zum Socket; das Modell sieht einen Platzhalter.

Gebaut mit Synsema

Drei Dinge, die Sie heute nutzen können.

Aus dem Blog

Benchmarks, Designentscheidungen, Anleitungen.

• September 2, 2026

  Ship a whole program as one binary with synsema build

  Engine, program, modules, templates and assets in a single sealed executable, with a capability ceiling baked in. Nothing to install on the target — deploy it FROM scratch, or hand it to someone as a file.

• September 2, 2026

  One program, three apps — web, phone and desktop from the same Synsema file

  A Synsema app is a website with automatic HTTPS, an installable phone app with native push, and a desktop app in its own window with your icon — from one server-rendered program and one API module. No native toolkit, no second codebase, no store required.

• September 2, 2026

  Expose your program to any AI agent — an MCP server in one route

  MCP is JSON-RPC. In Synsema the whole server is a dispatcher task and one POST route. Tools are tasks with real bodies, secrets stay sealed, and untrusted input runs under a capability ceiling.

Alle Beiträge → · RSS