Building blocks

Your company OS.
Built from working parts.

Reusable components for a company operating system. Start with a product to see what it does and how to use it. Below those, explore the implementation foundations and third-party tools we build with.

L · 01
Core components

Find the right building block.

WB

Workbooks

When a recurring spreadsheet job needs a tool of its own. Your workspace agent builds the logic and interface; your company owns the code, deployment and data.

Self-hosted · public release in preparation

Explore Workbooks
UF

Unformal

Conversation-first data collection for interviews, intake and feedback. A separate Spark product, not a third-party integration.

Spark product

Visit unformal.ai New tab
02

Workspace starter

A structured starting point for your company's knowledge, workflows, decisions and permissions. Give people and agents shared context before connecting the tools.

Workspace foundations · setup by agreement

Explore the workspace starter
L · 02
Implementation foundations

The parts underneath.

Libraries, patterns and tools we reuse in delivery. These support the products and implementations above; they are not all standalone products.

03

okf-graph

A Rust engine for Open Knowledge Format knowledge graphs: lint the graph, query typed relations, export it for a website, render it. Runs the Belgian accounting graph and a client's public knowledge graph.

Rust · MIT

04

Blueprints

The delivery patterns we reuse across clients: the agent workspace backbone, an agent workspace UI, a public marketing site with an agent layer, an agent-friendly wiki, multi-app feedback, bank integration via Ponto.

Patterns · proven

05

Typed CLIs

Command-line tools for the recurring admin of a Belgian business: tasks, CRM, banking, e-invoicing over Peppol. Agents call them the same way people do, with the same guardrails.

Tooling · in use

06

This site's agent layer

Every page served as markdown on request, an MCP server, a public API, discovery files. The pattern behind the page you are reading.

Public information · read-only

Explore the agent layer
L · 03
What we build with

Third-party tools that earned a place.

Fewer tools, each with real autonomy. These are the external tools that integrate cleanly with an agent workspace and pull their weight next to what we build. Each entry says what it is for and why it is the one we would reach for.

Directory
Use case mapped to why it wins

Picked for how well they compose.

T / 02

Slideless · External

Use case

Turns AI-generated HTML into shareable presentation links, so research and analysis land as readable decks instead of text dumps.

Why this one

Agents publish a deck with a single command, automating generation through distribution. Per-recipient tracking and version history that a wall of text can't offer.

T / 03

Patch · External

Use case

Clients comment directly on a live site; an agent turns those comments into pull requests for developer review.

Why this one

Built to orchestrate agent-driven development: feedback in, PRs out, with developers keeping full control through review before anything ships. Kills the scattered-feedback-to-code grind.

T / 04

Recommand · External

Use case

Peppol-certified e-invoicing: send and receive electronic invoices and procurement documents over the Peppol network, end to end.

Why this one

A clean REST API an agent can drive directly, open-source, end-to-end encrypted, and cheap (free up to 25 docs/month, volume-based after). Does exactly the one job a Peppol integration needs.

T / 05

Infisical · External

Use case

Secrets management: central store for API keys, certificates, and credentials, replacing scattered .env files across every environment and workload.

Why this one

Identity-based auth lets an agent fetch secrets just-in-time without a human pasting keys, the safe way to give agents real access. API-first, open-source, with rotation and an audit trail.

What should your company
stop doing by hand?

Bring one process that is slow, fragile or hard to change. We will look at what a useful first version could do.

Scope, cost and operating responsibilities are agreed before a build starts.