Scellis skripten: die API und der Copilot

Alles, was das Studio tut, tut es über eine API — dieselbe API, die du selbst aufrufen kannst. Das Interface ist ein Client der API, nicht umgekehrt: Jede Aktion in Scellis ist ein typisiertes Verb auf einem einzigen API-Service, und das Interface spricht genau diese Verben. Daraus folgt eine symmetrische, vollständige Regel: Was du klicken kannst, kannst du skripten; was du skripten kannst, erledigt der Copilot auf Zuruf; und dieselbe Fläche erreicht ein externer Agent über MCP. Diese Seite geht die programmatische Oberfläche ab — die Verben, die Aufrufer, das Zustimmungsmodell und die Linien, die keine Maschine überschreiten darf.

Das Interface ist nur ein weiterer Client#

Die meisten Anwendungen züchten eine private API für das eigene Interface und eine zweite, kleinere für alle anderen. Scellis hat eine. Forkst du einen Block im Katalog, ruft das Studio dasselbe catalog.fork auf, das auch dein Skript nutzen würde; pausierst du einen Run, dasselbe run.pause. Und Parität ist keine Absichtserklärung — sie wird automatisch geprüft: Dieselbe Operation über das Interface, über das rohe Verb und über den Copilot muss identischen Zustand erzeugen. Weichen die drei jemals voneinander ab, ist das ein vor dem Release abgefangener Defekt, kein Support-Ticket.

Verben, die sich wie das Produkt lesen#

Die Oberfläche ist in rund dreißig Verbfamilien organisiert, und die Liste liest sich wie ein Rundgang durch die Plattform. Lesen, Bauen, Ausführen und Nachverfolgen sind alles einfach Verben:

// The verbs the interface calls are the verbs you call.
const hits = await scellis.catalog.search({ q: "robust scaler", kind: "block" });
const prog = await scellis.program.create({ from: hits[0].id });
await scellis.program.compile(prog.id);           // Green / Yellow / Red — with diagnostics
const run = await scellis.run.start(prog.id, { tier: "prod" });
for await (const m of scellis.run.observe(run.id)) {
  console.log(m.epoch, m.loss);                    // 12  0.31  — live, downsampled
}
const lineage = await scellis.provenance.trace(run.id);   // both directions

Familie	Was sie abdeckt
catalog	suchen, erstellen, aktualisieren, forken — alles, was du hast, in einem Namensraum
program · model	erstellen, patchen, diffen, kompilieren, die abgesenkte IR inspizieren, 3-Wege-Merge; die volle Model-View-Oberfläche
run	starten, pausieren, abbrechen, beobachten — Live-Status und heruntergerechnete Metriken
publish · provenance	Arbeit veröffentlichen; vorwärts und rückwärts nachverfolgen, Links zum Reproduzieren ausstellen
workspaces · audit · sharing · invitations · notes · notifications	verwalten, protokollieren, einladen, annotieren, nachlesen
pools · jobs · federation · marketplace · billing · connectors · credentials · datasets	verteiltes Rechnen; Handel; Datenquellen und ihre Credentials; Datensätze — splitten, labeln, profilieren

Zwei Familien lohnen den genaueren Blick. program behandelt einen Workflow so, wie Versionskontrolle Quelltext behandelt — erstellen, patchen, diffen, kompilieren, die abgesenkte IR inspizieren, per 3-Wege-Merge zusammenführen — und steuert die volle Model-View-Oberfläche. Und run ist ebenso fürs Beobachten gebaut wie fürs Steuern: Ein laufender Job meldet Live-Status und heruntergerechnete Metriken — genug, dass ein Agent dein Training ehrlich mitkommentieren kann, „Epoche 12, Loss 0,3“, ohne Rohdaten abzuziehen — während provenance jedes Ergebnis in beide Richtungen nachverfolgbar macht und pools und jobs dasselbe verteilte Rechnen öffnen, das auch das Interface nutzt.

Wer aufruft — der Server entscheidet#

Identität ist bewusst schlicht. Skripte authentifizieren sich mit scoped API-Keys; das Interface läuft auf Sessions; externe Agenten koppeln über MCP. Aus der Art, wie ein Aufruf ankommt, ermittelt der Server, wer da ruft — du in der App, der Copilot, ein Headless-Skript, ein API-Key, ein externer Agent. Diese Antwort leitet der Server ab, der Aufrufer liefert sie nicht: Fälschen kann ein Client sie nicht. Der Unterschied trägt, denn die härtesten Garantien der Plattform hängen daran — die Geldregeln weiter unten halten, weil „ein echter Klick von dir, in der App“ etwas ist, das der Server verifizieren kann und nichts anderes imitieren kann. Wie genau diese eine Oberfläche für externe Agenten entsteht — und was ein Agent anfassen darf und was nicht — ist die Agenten-Oberfläche.

Abb. 1 — Der Assistent handelt nie hinter deinem Rücken. Er entwirft die Änderung als ganz normale Edits und zeigt dir den genauen Unterschied, bevor irgendetwas passiert; erst deine Bestätigung wendet ihn an. Was er getan hat, bleibt ihm zugeschrieben — und ein Undo nimmt es zurück.

Zustimmung in drei Stufen, überall gleich#

Jedes Verb, jeder Aufrufer, dieselben drei Stufen. Die Stufen variieren nicht mit dem Aufrufer; ein Skript kann sich also an keinem Dialog vorbeischleichen, den das Interface gezeigt hätte, und eine Schreib-Zustimmung zeigt den konkreten Diff, der gleich passiert — nie ein blankes „erlauben?“:

Stufe	Was sie verlangt
read	frei — Suchen, Inspizieren und Nachverfolgen kosten keinen Dialog
write	eine explizite Zustimmung, die die konkrete vorgeschlagene Änderung zeigt
destructive	eine Bestätigung, obendrauf rate-limitiert

Und ist der Aufrufer der Copilot, passiert nichts unsichtbar: Jede Copilot-Aktion erscheint als expliziter Tool-Aufruf — eine inspizierbare Programmoperation, sichtbar dort, wo du arbeitest, dem Assistenten zugeschrieben statt in deiner eigenen Historie zu verschwimmen. Er kann seine eigene Änderung sogar per program.undo zurücknehmen.

Der Copilot: sofort startklar, dann mit deinem Schlüssel#

Der Copilot funktioniert vom ersten Moment an: Ein Startkontingent ist enthalten, über den Server vermittelt, damit das Steuern von Scellis in natürlicher Sprache schon in den ersten Minuten trägt. Der Dauerzustand ist bring-your-own-key.

Hinweis

Dein Provider-Schlüssel liegt verschlüsselt auf deinem Gerät und landet nie auf Scellis-Servern. Jeder Aufruf zum Provider ist ein expliziter, in der Zustimmung sichtbarer Netzwerkeffekt — und eine Workspace-Policy kann ihn vollständig blockieren. Das volle Vertrauensmodell steht auf der Sicherheits-Seite.

Damit reicht der Copilot so weit wie die API:

Verstehen: alles suchen und erklären.
Bauen: Workflows und Modelle komponieren und bearbeiten.
Betreiben: Runs starten und beim Fortschritt beobachten.
Zusammenarbeiten: Notes verfassen und auflösen; Benachrichtigungen lesen und zusammenfassen — „was ist passiert, während du weg warst“.
Erweitern: kostenlose Packs installieren und altruistischen Compute-Pools beitreten — jeweils mit deiner Zustimmung.
Entwerfen: Merges und Freigabe-Vorschläge vorbereiten — annehmen tut ein Mensch.

Externe Agenten, über dieselbe Fläche#

Der Copilot ist nicht der einzige Agent, den diese Fläche bedienen kann. Externer Agent-Zugriff über MCP — Claude und jeder MCP-konforme Client als dritter Konsument — ist auf der Early-Access-Spur, und die gesamte Tool-Fläche wird aus der lebenden Verb-Registry generiert statt handgebaut: Eine neue Fähigkeit erscheint bei der nächsten Regenerierung, ohne dass ein eigenes Tool zu schreiben wäre. Kopplung ist eine explizite In-Tab-Geste; solange gekoppelt, zeigt der Tab einen dauerhaften „Agent verbunden“-Indikator, einen Live-Feed pro Aufruf und einen Ein-Klick-Widerruf. Lese-Aufrufe, die der Server beantworten kann, funktionieren ohne offenen Tab; alles, was die Engine berührt oder Zustand schreibt, wird an deinen einen gekoppelten Live-Tab relayed — kein Tab bedeutet nichts über Lesen hinaus.

Das Sicherheitsmodell, geschichtet#

Das Sicherheitsmodell ist bewusst geschichtet. Tokens sind kurzlebig und audience-gebunden an einen dauerhaften, widerrufbaren Agent Grant (du × Client × Scope-Set × Ablauf); Scopes sind eine Grammatik aus Namensraum × Consent-Stufe, die einen Commerce-Scope gar nicht konstruieren kann; Grant-Freigabe ist nur menschliche-UI, nie eine Selbst-Eskalation. Dieselbe Geld-Schranke, auf die der Copilot trifft, ist für MCP doppelt durchgesetzt — Geld-Verben werden bei der Generierung aus der Projektion ausgeschlossen und beim Dispatch erneut abgelehnt. Der Mechanismus ist Thema von die Agenten-Oberfläche.

Was kein Prompt freischalten kann#

Die Verbote sind strukturell, keine Einstellungen. Kein Agent — der Copilot, ein geleakter API-Key, eine Headless-Session oder ein externer MCP-Client — kann jemals kaufen, bezahlen, Trinkgeld geben, erstatten oder eine Auszahlung auslösen; Budgets erhöhen oder bezahlte Compute-Vereinbarungen eingehen; deine Credentials anfassen; eine Eigentumsübertragung oder einen Freigabe-Vorschlag annehmen (er entwirft, ein Mensch nimmt an); oder Kontolöschung bzw. Datenberichtigung ausführen (er zeigt dir das Recht, ausüben tust du es). Durchgesetzt wird das serverseitig: Geldbewegende Verben werden nur aus einer menschlichen Geste im Interface zugelassen, mit einer frischen Einmal-Nonce.

await scellis.purchase.checkout(listingId);
// ✗ refused — this call did not come from you, in the app.
//   A payment clears only from a real click, carrying a one-time
//   token. No API key, no script, and no agent can mint one.

Abb. 2 — Die eine Linie, die keine Maschine überschreitet. Eine Zahlung geht nur durch einen echten Klick von dir in der App durch, mit einem Einmal-Token, das sie nicht wiederverwenden kann — Copilot, Skript und externer Agent werden an derselben Schranke abgewiesen. Nicht, weil wir es ihnen verboten haben: weil es keinen Weg gibt.

Genau deshalb kann ein prompt-injizierter Copilot, ein geleakter API-Key, eine Headless-Session und ein gekoppelter MCP-Agent trotzdem nicht kaufen — nichts davon kann ein Mensch im Interface sein. Ein paar weitere Momente bindet das Sicherheitsmodell des Browsers selbst an eine Geste — eine lokale Datei auswählen, ein OAuth-Popup abschließen — und dort bereitet der Copilot alles vor und reicht dir einen einzigen klaren Schritt zum Abschluss. Auch deine Rechte an deinen eigenen Daten sind Verben: Auskunft, Export, Berichtigung, Einschränkung, Löschung — erstklassige Operationen, beantwortet innerhalb eines Monats. Der Copilot zeigt dir den Weg dorthin; ausüben tust du sie selbst.