Humans read the page.
Agents read the source.

What you build with it

An AI agent framework and a programming language, in one binary.

Everything an agentic app needs is in the language, not in a framework glued on top: LLM calls, tool use, memory, human-in-the-loop, multi-agent orchestration, a production server and the security model. So the same language also builds the API, the site, the phone and desktop app, the cron job and the CLI around the agent.

One file

The whole backend, with its permissions on top.

A Synsema program opens by declaring what it may touch. Everything under that line runs inside it: the routes, the database, the secrets, the model. Both files below parse and run as written.

-- 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 is the permission surface. A port, one database file, one secret. A fetch to any other host is refused by the interpreter.
• Auth and validation are declarations. auth with names the task that says who a token is; expect body rejects a bad payload with a 400 that names the field.
• One route, every reader. content() answers HTML to browsers and Markdown or JSON to agents; paged() pages big result sets for you.
• The model is a primitive. decide returns one of the options or retries; analyze and generate are typed, not prompt strings glued by hand.
• A human is a primitive too. approve … within 1h blocks on a real person; with nobody there, it denies.
• Secrets never materialise. The key travels sealed to the socket; the model sees a placeholder.

Built with Synsema

Three things you can use today.

From the blog

Benchmarks, design decisions, how-tos.

• 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.

All posts → · RSS