Features

Every model in the fleet carries a manifest with its weights digest, source, licence and promotion date. The router refuses a model whose digest drifted and health shows it.

Each inference writes a hash-chained row with the agent, manifest, module, lane, resolved model, prompt and output hashes, tokens and latency, spooled locally when the store is away and sealed with a signed daily root that anyone can verify.

Each agent declares the tools, collections and hosts it may touch. The tool dispatcher checks the manifest on every cascade step and agent loop; an unknown agent is denied, a known agent without a manifest gets read-only tools, and every denial is logged.

Produces the Annex IV technical documentation and a risk classification per AI use from the lineage ledger, the model registry and the routing configuration, as a versioned document per module.

Hash-chains the audit history across the platform and the Robeeflow hub and exports it to write-once storage on a schedule, with a verifier anyone can run.

Scheduled PocketBase snapshots are restored into a scratch instance and a report says what came back, so a backup is proven rather than hoped for.

Every framework skill can be exported as a standard Agent Skills package that any agent runtime can load. Outside skills come in only through an intake flow that records their origin.

The platform is governed by a versioned framework of laws, roles, skills, flows and templates with a proposal lifecycle and a linter. Version 11.1.0 adds the Agentic Accountability law, the Correspondent role, crawl and correspondence conduct and six runtime error codes.

The platform records what people and AI agents did, through one function behind the API, the admin page, MCP tools, chat tools and cascade steps. Commits, changelog entries and each agent's daily activity are ingested automatically, and a period renders as a report with highlights, a timeline and decisions in Markdown, HTML and JSON.

Multi-step agent pipelines defined in YAML with solo, chain, event and loop types and http, agent, job, wait, geo lookup, database and OTEL logging steps. Event cascades watch any collection and fire when a record matches.

Police, Documenter, Janitor, Linter, Medic, Librarian, Enricher, Cipher, Hunter, Scout, Curator and Assessor each own their cascades under a distinct identity, so a report always says which agent did the work.

Every cascade run files a rendered report with the full step output, grouped per persona, and idle runs stay quiet so the report list only holds work.

One view over every cascade, task and agent with step drill-down, schedule pills and live job events in the notification bell.

A living, seeded roster of the agents with their inner thoughts, a chat per agent, and skills an agent can request and an operator can grant.

Agent output lands in a review queue where an operator approves it, awards bonus XP and sees the verifier's grade before anything is taken as fact.

Every agent earns XP per completed task with an event log of when and why, levels up as it accumulates, and can be granted bonus XP from the workforce view.

Autonomous background research with a grounding gate. Every report is verified against the evidence it gathered, graded A, B or C, has dead links flagged, and a company's own site never counts as independent confirmation.

The Librarian classifies a topic before it starts and uses a brief and an acceptance bar specific to that kind of topic.

Head-to-head comparisons and trained-knowledge dossiers on routed lanes, rendered as reports.

The Documenter derives every page's prose, controls and API endpoints from its source, refreshes screenshots, and a test fails when a documented endpoint or control stops existing.

Cron-style scheduling for time-based and event-triggered jobs, with a run-on-startup flag and a failure model that never disables a job permanently after one bad run.

The numbers that used to need SSH: what fails quietly, what is stuck and what is falling behind, in one page.

Intake, in progress, done and archived columns with drag and drop, nested sub-todos, tags, priority and due dates. Agents move cards through MCP.

Memories survive sessions, are scoped to the user, deduplicated by content hash and enriched in the background with keywords, so the assistant remembers preferences, project state and history.

A local model assigns categories and a nightly pass merges duplicates, so the memory store stays tidy without anyone curating it.

Documents are embedded locally and recalled by meaning as well as by keyword, with a disk cache so re-indexing is cheap.

A visual graph of memories and the entities they mention, for seeing how what the assistant knows hangs together.

An intelligent file indexer with cross-references, headings, keywords and code blocks per document, searchable by agents through MCP tools.

A local-first key-value store with dot-notation keys and TTL, readable and writable by agents through MCP tools and curated by a Context Curator cascade.

Every prompt is assembled within a token budget and the MCP bridge is a sensitivity boundary, so a model only ever sees what the operation needs.

Each operation names a primary and a fallback local model with thinking under routing control. Untagged calls fall back to the chat lane, and a local-only box is a configuration, not a failure.

Routing can name local models served by Ollama, which waits for the GPU at boot and keeps two models resident so nothing is ever loaded partly on CPU.

A fleet yardstick that records every ask, response, time and verdict, runs as a daily cascade and produces an Assessor brief, so promotions are decided on measurements.

One linked trace per chat turn, cascade, tool execution and background job, with span trees, a waterfall, request and response capture and the operation each span served.

Per-operation usage from the traces, a daily trend, a model by operation matrix and a fleet-wide view where every caller, including standalone binaries, is tagged.

A pluggable cascade step that writes OTEL logs to disk or a collector with standard resource attributes, and a log viewer page.

Image generation runs on the local GPU and is switched on from the dashboard, closing the last hosted door.

Identifiers are found locally by rules first and the remainder is routed to a local model, so personal data is classified without leaving the machine.

A user can set their own provider key and default model and it takes precedence over the platform defaults, with requests, tokens and estimated cost tracked per user.

Nightly model discovery records every run in a ledger shown on the page, flags fleet candidates for the Steward instead of pulling them, and stops entirely under the zero-egress switch.

Every action, including logins, tool calls, memory writes, vault reads and admin changes, is written to an append-only record with method, path, IP, user agent, status and duration.

Every login is a tracked session with a device hint, IP address and last-seen time; all active sessions are listed and any of them can be revoked with one click.

Time-based one-time codes as a second factor on sign-in.

Single-tenant Microsoft Entra ID and Google sign-in, with the server saying at boot which buttons are live.

User secrets encrypted at rest with AES-256-GCM under a profile-level master key, sealed automatically after inactivity and unsealed explicitly.

Secrets an agent may use, published from the personal vault one at a time, with tool-level restrictions, sensitivity flags and an access trail, exposed as MCP read, write and list tools.

Memories live under user-scoped paths so a cross-user read is impossible at the filesystem and sync layers, not just in the API.

API keys carry an identity and scopes, are rate limited per key, and are logged only as a short prefix.

Signature detections need three strikes, bans escalate and expire, known users are exempt, and a proxy address is trusted only when declared.

Manage users and admin access from the dashboard with named roles that can only ever grant, and every change reaching the audit log.

A daily cascade asks whether anything known to be vulnerable affects what actually runs, across the Go modules and npm packages, and files a task per finding.

The platform publishes its security contact and its guidance for language-model crawlers at the standard locations.

A user can export or delete their own data from the account pages.

Any page becomes clean JSON and Markdown with title, headings, body text, internal and external links, word count and depth, with readability extraction and headless Chrome escalation when a page needs it.

Crawl a page, a section or a whole domain within a depth and page budget, build the site tree as pages are found, and map a site from its sitemap.

Extract fields from a page against a saved JSON schema or a prompt, on the spectre routing lane so usage accounting and routing edits apply.

Watch a page on a schedule, pause and resume it, and see a line diff when the content changes.

Run many URLs as one asynchronous batch with bounded concurrency and a completion webhook.

Web search across several engines with an answer synthesised on the spectre lane; hosted engines are used only when their keys are set.

Pull the images and the ranked keywords out of any page.

Convert PDFs and other documents to text and Markdown, singly or in batch.

Vulnerability feeds and a dependency scan, so Spectre can say whether a finding touches something you run.

Domains discovered during a crawl land in the hopper for labelling and chaining; seed lists start recurring crawls from a curated set.

Topic-driven automatic research with daily briefs, editable topics and themed report downloads. The report cites every claim to a numbered source, its confidence comes from source agreement, and a verifier on a second model family checks it.

One shared robots cache is consulted by fetch, extract, map, watch, batch and scout, crawl-delay is honoured, and the only override is an admin action that is recorded.

A tenant policy that disables every hosted lookup, keeps captcha solving and public search local, and stamps every result with an egress attestation.

The local PII detector runs over every page and findings are redacted or tokenised before results reach a model, disk or a webhook.

Raw response, headers, rendered DOM and screenshot per fetch as WARC, hash-chained by day and signed, with a verify endpoint and MCP tools to fetch and verify evidence.

First-class packs for TenderNed, officielebekendmakingen.nl and the KVK register with seeds, a schema, a watch preset and legal notes.

Spectre crawls SharePoint, Confluence and internal wikis on the same network under an allow-list with redirect and DNS-rebind protection.

Captchas are read by a local vision model, so zero-egress mode does not need a hosted captcha service.

Schema extraction and search answers run on the spectre routing lane instead of the default chain, so routing edits and usage accounting apply to them.

Batch and watch policies are stored with the job, so a run keeps the conduct it was started with.

Ask Fetch for markdown, html, raw html, links, a screenshot or json and get only that back from the cached capture, so a caller never pays for formats it does not read. Screenshots are reachable from the API.

Wait, click, type, press, scroll, run a script, take a screenshot and scrape as named steps in the same Chrome session, each recorded in the result, so login walls and infinite scroll are crawlable without a raw script.

One schema runs over every page of a crawl or a URL list as a job, chunked and merged into one result and validated with a retry, on the local spectre lane.

Limit, depth, include and exclude paths, subdomains, external links, sitemap mode, query-parameter handling, delay and concurrency are set on each crawl, map and extraction instead of once for the whole tenant.

Each request says how old a cached capture may be, how fresh it must be and whether the new capture is stored, and every answer carries the time it was captured.

A change-tracking format on Fetch compares a page with its previous capture and answers with the previous capture time, a status, a git-style diff and a schema-driven field diff, with tags for separate histories.

After a hash change a local model says in three sentences what changed and gives a materiality score, so cosmetic diffs stay below a threshold and the real ones get noticed.

Started, page, completed and failed events for batches, extractions and watches are delivered with an HMAC signature header and retried, so a receiving system can trust and replay them.

Every check, tracking fetch, batch and extraction is a job that can be cancelled, lists its errors and pages its results with a cursor.

Batches drop duplicate URLs, take their own formats and schema, respect the browser pool when running concurrently and page their results.

A link to a PDF, Word, Excel or CSV file is read as a document with page markers and a parser-and-confidence record, and a scanned PDF is transcribed on the local vision lane.

Fetches run under a basic, stealth or auto browser tier with a retry on bot detection, and each tenant's proxy pool is passed into Chrome.

A country and a language list set the Accept-Language header, the Chrome locale and timezone and pick a matching proxy, so a page is seen as a local visitor sees it.

Charts are captioned, scanned notices transcribed and cookie-walled pages checked by the local vision model, and the captions feed back into image extraction as alt text.

Scrape, crawl, map, search, extract and watch are served over MCP with streamable HTTP and a stdio proxy for Claude Code and Cursor, behind the same scoped API keys, so outside agent runtimes call Spectre natively.

A versioned Spectre API with scoped, quota-metered keys and per-key limits, an OpenAPI description and thin Go, TypeScript and Python clients.

Every fetched page is embedded on local models that never leave the server, keywords are ranked by meaning instead of frequency, and everything Spectre has ever crawled is searchable with near-duplicate detection.

Crawl, extract, map, search, convert, images, CVE, link health, evidence and more are callable by agents as MCP tools, and by API key from outside.

Agents can post to a Discord channel or send a direct message through the platform's bot.

The platform receives mail on its own listener with IP blacklist, honeypots and relay protection, and sends through a direct relay.

The raw message is kept as a file with the full header map and attachment list, and bodies are no longer truncated.

Message-ID, In-Reply-To and References are stored and emitted, a thread id is computed, and threads show in the mail page.

An unknown recipient gets a plain refusal instead of a blacklist strike, so a legitimate mail server delivering to the AI address is no longer treated as a relay probe.

Guard, understand, draft, verify on a different model family, decide, send and record. Every mailbox starts in draft mode, so replies wait in a queue with Approve, Edit and Reject until an operator chooses autonomy per mailbox.

Auto-submitted, bulk, list, bounce and self-addressed mail is never answered, and AI replies are marked so other systems do not answer them either.

Sender and domain policy per mailbox plus a suppression list, checked before any draft is written.

One record per stage with the model, lane and prompt hash, shown as a timeline on the mail and counted in the usage tables.

The mail page shows the state of the domain's MX, SPF, DKIM and DMARC records, so a missing record is visible before anyone wonders why nothing arrives.

When a selector is set the deploy creates the DKIM key, wires it in and prints the TXT record to publish.

The framework binds the mailbox to a Correspondent role with answer-only authority, hold by default, quotas and an escalation path.

The hub runs as a self-contained plugin with its own PocketBase in the platform's storage tree, proxied under the platform origin and gated to admins, and bridged into the AI, logging and reporting.

A visual designer with the full node palette, including Validate, Transform, HTTP Request, Log and Schedule nodes, so time-triggered flows run without code.

One row per execution with a node timeline and a re-run button.

Every save is a version you can roll back to, a flow can be dry-run before it goes live, and an error edge routes a failed node instead of aborting the run.

Export the hub's configuration as a bundle with secrets removed, and import one with a diff before anything changes.

Outbound ebMS 2.0 with reliable delivery, an inbound listener over two-way TLS, a delivery screen and a send node.

Signed synchronous SOAP 1.2 in both directions.

OAuth 2.0 with private_key_jwt, mTLS entry points and REST entry points that run flows.

An AS4 / ebMS 3.0 profile puts Digikoppeling ebMS3 and Peppol on the same outbox, inbox and trust store, with SML/SMP dynamic discovery at send time and encrypted payloads.

Large payloads travel out of band under the Grote Berichten profile.

Messages are signed and verified with WS-Security on the request path.

A daily mirror of the Logius OIN register with a public API and a lookup on the agreements and partners pages.

Import an agreement from a cpa.xml file instead of typing it.

An inventory of everything that expires, alerts, CSR generation, install and rotation, with signing certificates verified against PKIoverheid and revocation checked through OCSP with a CRL fallback.

A screen for the trust anchors with checks at entry.

Volumes, partners, acknowledgement latency, what is stuck and a per-message trace.

Received and sent messages are archived and expire under a retention policy.

Replay a received message and hold an endpoint back when it is overwhelmed.

Replay a real received message into a dry run with personal data masked, so an integrator can debug production traffic without seeing it.

Dead letters and rejections raise an announcement and a mail, once per agreement.

Keys, API keys, tokens, partner credentials and connector licences are sealed at rest with a lookup hash beside them and masked on read.

Stored message bodies are encrypted, and the vault degrades to a visible warning rather than taking the hub down when the key is missing.

An outbound-only on-premise connector runner enrolled from a screen, with a work channel, a job queue with retry and cancel, and signed requests that are accepted once.

A connector picks up files from a customer's SFTP server, a folder or an HTTP endpoint, provisioned from the hub, with host keys pinned and source secrets sealed.

A loopback conformance run and a simulated partner for connection tests.

Import exit points from an OpenAPI description.

One page that says whether the hub is ready for production, including interoperability and trust anchors.

The hub's health endpoint reports degraded when something it depends on is missing, instead of always answering fine.

Leased singleton roles, a claim-before-run inbox and a flow concurrency ceiling, so a second hub is safe.

Every message definition's fields, types and required flags in one searchable view, derived from what already exists.

Response time and availability commitments per customer, so the logs have something to be judged against.

Edit field mappings, inspect a connector and read a record's history in the hub.

The platform's agents operate the hub through MCP tools.

Partner profiles with a pinned host key and sealed credentials, transfers over secure file transfer in both directions, over HTTPS and from watched folders, encryption at the payload level, checksums that travel with the file, retries with backoff and a restart from the byte a transfer stopped at.

The personal-data vaults, the AI bridge and their console are one module of the dashboard beside Nexus, Sentinel and Spectre, with an overview of every vault's records, key state and rotation, the protocol chain check, the grants waiting for approval and the reads attested recently, and a page per part.

One card per vault with its record count, purposes, protocol rows and key version; records are shown masked by field class and a field is revealed only with a recorded reason. The developer Vault Explorer is retired.

A purpose and its lawful basis are registered per vault and per consumer before any read, free text is refused, and a purpose that touches the BSN needs a Guardian's approval.

Every read of the people vault writes a hash-chained protocol row with who asked, under which purpose, which fields came back and a hash of the record, without a raw identifier. The archiver never touches the chain and a person's protocol can be listed.

Each vault has its own data key wrapped by a platform key, every record carries its key version, and rotation re-wraps the keys without re-encrypting every record.

A hashing key separate from the encryption key produces the lookup hashes for BSN, KVK and address keys, every BSN passes the elfproef first, and the hub's logs only ever show a hash prefix.

Look a person up under a registered purpose and produce an access export with protocol history, rectify with before and after recorded, reveal with a reason, and delete with a tombstone so a later import cannot bring the person back.

Ask the chat about a person, building or company and the local model calls a server-side vault tool whose result is filtered and redacted by class before it enters the prompt, cited back to the record and its protocol row. An unlock ceremony precedes the first read and a hosted model lane is refused by code.

External agents call vault search, get and verify over MCP with a key scoped to one vault, purpose, field set and rate, under the same checks and the same protocol and lineage rows as chat.

An agent or flow step queries a vault for another agent under that agent's permission manifest, receives only the allowed fields, and both agents are linked to the record in the lineage. BSN-class fields never reach a step that sends outward.

Every AI-side caller, whether a chat tool, an MCP key, an agent or a flow node, holds a scoped bridge key that exists on the server only as a keyed hash. A second approver is needed to unlock a BSN purpose.

Every vault read through chat, MCP or an agent returns a signed egress attestation naming the local lane and model, the fields and classes returned and the protocol and lineage identifiers, so an auditor can see the data never left the server.

Every field of every vault carries one of six classes, from public to secret, and that class decides what is masked on a screen, what a purpose may receive, what may reach a model and what may be exported. A field the schema does not name fails the read closed rather than passing as harmless.

The register of processing activities required by article 30 is rendered from the registered purposes, the classification schemas and the vault configuration alone, versioned by content hash, signed, and regenerated whenever a purpose or a retention term changes, so it cannot quietly drift from what the platform does.

The data protection impact assessment is drafted from the same configuration, with the three mandatory triggers read from it rather than asked of anyone, the mitigations already in force listed with links to their evidence, and the open risks named. It stays a draft until a person signs it.

Revealing a citizen service number or a special-category field needs a second administrator to approve a request that is valid for fifteen minutes and for one reveal, and the request, the approval and the reveal are all recorded. Break-glass without a second person takes an explicit flag and raises an alert.

Every vault has a retention term, from the archive selection list or the customer's own decision, and a legal hold that freezes deletion until a recorded decision lifts it. A daily sweep respects both and the page shows what is past its term before anything is removed.

Seven rules over the access record, from bulk reads and off-hours reveals to failed decrypts, break-glass and a broken chain, raise an alert and a notification, and the serious ones open an incident carrying the seventy-two hour clock from the moment awareness began. A rule counts rows and hashes and never names a person.

Ask the population register live for one person or a search, with the fields taken from the registered purpose and the authorisation so nothing unauthorised is even requested, over the government transport with your own certificate. The answer is written into its vault and both the acquisition and the provision are recorded.

Address and building lookups from the national buildings and addresses register, kept within the published rate limits before the call rather than after a refusal, and cached only for freshness. A person or a valuation links to a building identifier instead of a free-text address.

Property valuation queries limited to the fields the supervisory authorisation matrix gives your role, which narrows the answer once more after the purpose and its field list. Every value is stored with its reference date and the authority it was obtained under.

Company profiles from the Chamber of Commerce search, basic profile and establishment profile. The registration of a sole trader or a partnership is stored as personal data, because their trade name is often their own name and their registered address often their home, while the facts about the registration stay public.

The organisation identifier register is mirrored into a vault of its own through the access layer with a daily refresh, keeping parent and sub-identifier relations, the Chamber of Commerce cross-link and a freshness stamp and provenance on every lookup.

A record names the customer it belongs to, and an authorisation names the people it covers rather than the whole register, the way a Dutch autorisatiebesluit does. A read is answered for the caller's own customer, an authorisation can be narrowed further to one municipality or any other field of the record, and reaching across customers is a declared, operator-only act that says so on every row it writes.

A card per record showing its lookup hash, the key version that sealed it, when it was written and which customer it belongs to, and no field of the record at all, which is the most a list may lawfully see. The card carries the hash a read needs, so a record is opened without anybody having to know a citizen service number, and the number itself stays behind the reveal step. Each page of cards is one recorded read naming the page rather than a person.

An operator gives an owner to records that have none, either one customer for everything matched or by a field of the record, so a municipality is given the people registered in it the way an autorisatiebesluit reads. The run counts before it changes anything, reports which values it could not place, and is reached from the console, the API, agent to agent, over MCP and in chat.

A person can ask for their record to be withheld, which the population register calls a verstrekkingsbeperking. It then disappears from every read, search and count, and a single time-boxed look at it needs a second administrator to approve. A record that is out of scope, withheld or genuinely absent answers in exactly the same words, so the answer itself reveals nothing.

Every file is hashed on arrival and kept once under that hash, and every open, download, share, hold and deletion is one row in a per-day chain whose root is signed, so one verifier answers for documents, audit rows and vault reads alike.

Each document is sealed with its own data key, wrapped by its tenant key, wrapped in turn by the platform master key, so a rotation re-wraps keys without touching a single document and a sealed tenant cannot be read by the operator.

Every document carries the archival elements a Dutch archive expects, from creator and retention term to checksum and file format, plus exactly one of the six classes that decides masking, sharing and export. A document without a class does not save, and the content scanner may raise that class but never lower it.

A new upload of a known document becomes a new version linked to the previous one, and a deletion leaves a tombstone with actor and reason, so the same bytes cannot quietly come back and content disappears only once retention and holds allow it.

Share a document with a named recipient under a purpose, an expiry, a download limit and an optional view-only mode with a watermark. The link is shown once and kept only as a hash, so a lost link is reissued rather than recovered, revocation is immediate, and every open and every refusal is recorded.

Every list, read, upload, share and deletion passes one layer on your own server that resolves who is asking, applies the class rules, decrypts, writes the row and attests what left. The console and the API, the agent steps, the MCP tools and the chat tools are doors onto it and hold no rule of their own.

Every read on any channel writes a tamper-evident row with actor, purpose, channel, document hash and version, class and outcome, kept append-only for its legal term, so a steward answers who saw what and a person can list the rows about their own documents. A read whose row cannot be written is refused and no byte leaves.

Each document inherits a retention term from its archival metadata or its class, a daily run tombstones what is past term and removes the bytes after a grace period, and a legal hold for a dispute, a public-records request or an investigation freezes both until a recorded decision lifts it.

A node-graph designer with tree and canvas views, a palette built from the 202-assertion reference, editable author comments and a byte-identical serializer.

Publish a designed policy to a gateway with a preview first, and pull policies from a GitHub repository over a deploy key.

Every authored policy is graded against a security baseline and passes both checkers automatically before it can ship.

Policies are graded against BIO/BIG, NIS2 and the NCSC web guidelines.

Run a policy against saved cases and a suite of them, and see which node decided the outcome.

A weekly sweep of the app's own API surface and declared targets with scan levels L0 to L4, findings with history, lifecycle and muting, and an accepted-adjusted grade.

Ready-made policies for an FSC inway and outway with token introspection, graded at A on the security baseline.

Identity, peers, directory, services and contracts managed from one module.

Token authorisation, an inway and an outway, mTLS with certificate-bound tokens and a real inway listener.

RFC 8785 canonicalisation and detached JWS contract signatures, multi-peer federation, and a peer token endpoint with authorisation bound to the caller.

The Digikoppeling REST-API 3.0.0 profile implemented on the FSC runtime.

Addons declare their purpose, capabilities and governance in a manifest that the workforce reads, so an agent can find and use a module it has never seen.

A reusable connector over SSH deploy keys, wired into Layer 7 and cascades.

Reads an Adeptia Connect export and produces a migration plan to Boomi: every flow with a diagram, every mapping classified by effort, a wave plan and a readiness score.

More than 150 MCP tools across memory, documents, key-value, Spectre, the vault and Robeeflow, so agents and external developers share one surface.

Every route is documented and served as one OpenAPI description with real response schemas, and a test fails when a route is missing from it.

Export and import the platform's configuration as a bundle, with a dry run first.

Outbound webhooks on platform events.

A pipeline, a bid/no-bid qualification, an answer library, questionnaires with blind-spot analysis, and DOCX export.

Contacts, deals, MEDDPICC qualification, a forecast and a heatmap.

Projects with tools, an ideas backlog and reminders, all owner-scoped.

Which lane runs on which model, whether each chain has a local answer, and cascade health at a glance.

The laws, skills, flows, templates, glossary and manifest of the framework, readable in the product, with a leaderboard and XP progression.

A skill tree that tracks mastery as agents and users complete work.

One unique AI creature per user with rolled stats, evolution, missions, accessories and thoughts, generated on the local image model.

Every buddy creature is painted by the local FLUX model on your own GPU in one house style, a flat hand-drawn cartoon, and an admin action repaints the whole fleet after a style change.

Buttons, fields, cards, badges, modals, tables and more in one package with derived on-colour text and status families, used by every page.

Sixteen themes, one flat file each, switchable per user with a font picker and a theme audit.

Every colour is a design token; the palette lint, the undefined-token check and the ratchet run in the deploy so raw colours cannot come back.

A raw-primitive lint rule, an extended palette lint and a component index page, with a baseline that only ever rises.

Every record about a message, a flow run, a chat turn or a cascade carries the same transaction identifier, and the identifiers that already existed keep their meaning beside it. The same copyable chip shows it wherever a transaction appears, and pasting it into the search lands on the same story from either product.

A run on the integration hub appears in the platform's trace store beside chat turns and cascades, with each node, send and acknowledgement as a step, while the hub keeps its own record of the run.

The hub's AI node calls the platform's governed model interface, which refuses anything but a local lane by code, so every inference the hub makes gets a lineage row, a span and a usage entry with the run, the node and the message attached. Per message you see which model was asked what, and at what cost.

Replays, reruns, sandbox runs and dry runs are recorded runs with a kind and a parent, so the original message and run list their children and how each ended. A sandbox run keeps only masked facts and counts.

Paste any identifier and get one ordered list of everything that happened because of it on both sides, from the message received through nodes, AI calls, deliveries, acknowledgements, alerts, replays, cascade steps and audit rows, each with its source, state, duration, links and hashes. The same answer reaches the chat and the agent tools.

The deploy rebuilds and restarts the services that changed, fails when a stale binary is left behind, and preserves sovereign file ownership.

A diagnostics page that checks the pieces the platform depends on and says which are missing.

A public status page for the platform.

PayPal subscriptions and comped plans, with feature access decided by role and plan.

The Go server terminates TLS itself for more than one domain and redirects to the canonical host.

Every text response is compressed and static assets are cached, with WebSocket upgrades left alone.

A cascade run killed by a deploy restart is recorded as interrupted rather than failed, the Self-Healing cascade re-fires at the next boot, and the deploy waits for running cascades before it restarts anything.

The local image service shares the GPU with the language models and decodes on the CPU, so it no longer runs out of memory beside them, and the buddy says when the service is not running instead of showing a placeholder.

A language model that does not fit beside the others on the graphics card used to be split onto the processor in silence, which costs minutes on every call. The fleet now checks where each model actually landed and reports a split model as a fault instead of letting it run slowly.

The local image service no longer holds sixteen gigabytes of video memory around the clock. It starts when an image is asked for and gives the memory back to the language models when it is not.