Les humains lisent la page.
Les agents lisent la source.

Ce que vous construisez avec

Un framework pour agents IA et un langage de programmation, en un seul binaire.

Tout ce dont une application agentique a besoin est dans le langage, pas dans un framework collé par-dessus : appels au LLM, outils, mémoire, validation humaine, orchestration multi-agents, un serveur de production et le modèle de sécurité. Le même langage construit donc aussi l'API, le site, le cron et la CLI autour de l'agent.

Un fichier

Tout le backend, avec ses permissions en tête.

Un programme Synsema commence par déclarer ce qu'il peut toucher. Tout ce qui suit s'exécute à l'intérieur : les routes, la base de données, les secrets, le modèle. Les deux fichiers ci-dessous se compilent et s'exécutent tels quels.

-- 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 est la surface de permissions. Un port, un fichier de base de données, un secret. Un fetch vers tout autre hôte est refusé par l'interpréteur.
• Auth et validation sont des déclarations. auth with nomme la tâche qui dit qui est un jeton ; expect body rejette un payload invalide avec un 400 qui nomme le champ.
• Une route, tous les lecteurs. content() répond en HTML aux navigateurs et en Markdown ou JSON aux agents ; paged() pagine les gros résultats pour vous.
• Le modèle est une primitive. decide renvoie une des options ou réessaie ; analyze et generate sont typés, pas des chaînes de prompt collées à la main.
• Un humain aussi est une primitive. approve … within 1h attend une vraie personne ; sans personne, il refuse.
• Les secrets ne se matérialisent jamais. La clé voyage scellée jusqu'au socket ; le modèle voit un marqueur.

Construit avec Synsema

Trois choses à utiliser dès aujourd'hui.

Sur le blog

Benchmarks, choix de conception, guides.

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

Tous les articles → · RSS