Every capability in the platform on one screen, filterable by block, for when you need to check whether something exists
The other pages in this section argue a case. This one is the index.
Every capability the platform carries, grouped by the block that owns it, filterable when you are looking for one thing. Use it when the question is "do they have X", then follow the card through to the page that answers "how does X work".
For the same set arranged as a stack, see Architecture: the seven layers, and what each one is assembled from.
An application that already knows your people, your catalogues and your data, keeps its own balances, reports on itself, reaches outside systems, and has AI employees working in it
You state what is needed, an AI assistant turns it into a specification you approve, an AI agent builds it through gates. Nothing reaches a live system without a person saying so
An application is a git repository of typed artifacts and a registry of the requirements they trace back to: assembled rather than coded, installed by a reconciler, and versioned like software because it is
Portals, application screens, dashboards and forms - from a catalogue of well over a hundred and fifty widgets, each bound to real data and shown to the people it is meant for
Internal software is allowed to be as considered as the apps people choose for themselves - one design system, themes you set once, and screens you judge by looking at them
Describe the screen, correct what comes back, and let the widget you clicked tell you what it could do better - the catalogue is large so that nobody has to learn it
A page is a declarative document validated against one schema and rendered by a native player - with data reaching it only through the engine's contract, which is what makes access rules hold on a screen
Units, positions, people and roles, taken from the system that already holds them and resolved at the moment a process needs an answer instead of written into it
Employees with a role, a manager, a scope, a budget and a record, hired into the same organisation as everybody else, not agents that perform tasks
How a described role becomes an enforced scope: tool scoping per role, an ordered gate in front of consequential actions, metering that cannot be bypassed, and one audit trail for both kinds of actor
Requests with real fields, routes that resolve who approves from the org structure, boards to work them on, and the answer arriving from whichever channel the person actually uses
The form is what the record already is - generated from its fields instead of drawn, arranged when you want it arranged, and openable anywhere the work happens
The half of a process nobody should be doing by hand - what starts it, what it reaches, and why a scenario that takes three days survives a restart on the second
Describe the approval you need and get a working process - and put an agent inside a running scenario as a step that has to answer for itself
One persisted object model - models, tasks, transitions and nodes - executed by two runtimes, which is why a three-day scenario and a service restart are the same kind of non-event
A shared grid with the formula library people already know, and columns that can hold a person, a task or a row of a dataset instead of text that looks like one
What Excel and Google Sheets are genuinely good at, where the line runs, and the two sheets you cannot build on the other side of it
Nobody has to build the budget model by hand any more - the assistant produces the sheets, the links and the formulas, and it arrives as part of an application with its approval route attached
The round-trips a spreadsheet usually needs - export, upload, paste, remind somebody - stop existing when the sheet is already inside the system the data was going to
Two representations of the same sheet - a live collaborative document and a relational projection - and the rules that keep them from disagreeing
Loyalty points, warehouse stock with batches and expiry, mutual settlements, budget limits - four things companies usually build four times, on one register
The decisions that make a balance survive concurrency: integer amounts, ordered locks, isolation enforced by the database, and reconciliation that reports rather than repairs
Declare the entities your business actually has, let the people who know them keep them current, and have every other part of the platform read the same list
Free attribute evolution and native query speed at the same time: a fixed table plus JSON attributes, with the declared ones promoted to indexed generated columns
Self-service analytics on a serious engine: connect what the company already runs on, get your own answers without filing a request, and put the dashboard where the work happens
Every other BI is a layer over the systems where work happens. Here the analytics is inside them, so a finding can be discussed, assigned and acted on without leaving the screen it turned up on
Ask for the cut you want in words and get the widget itself - over your data, inside your access rights, and shown to you before it is saved
The engineering of the analytics front end: how a result set becomes a table you can scroll, a chart you can click, and a screen that filters itself
What can be connected, when a question is answered at the source and when from the platform's own data lake, and how freshness is decided
One description of what the company's numbers mean, built with help instead of by hand and defended against the join traps that quietly inflate a figure
The assistant works the data, builds the objects an app is made of, and leaves the requirements behind as a versioned repository instead of writing you a query and disappearing
The architecture end to end: what executes a query, why Rust, DuckDB and Arrow, how caching and backpressure behave, and where access control is applied
Threads, mentions, reactions, attachments, live co-editing and a history of what happened - with your AI employees writing in the same threads as everybody else
One polymorphic anchor, one store, one API and one component for every kind of object, with access reusing the platform's own checks, and two realtime mechanisms because discussing something and editing it together are different problems
A set of specialised agents with their own instructions and their own tool scope, running in the cloud or on your own hardware, executing declared operations in the platform instead of producing plausible text about them
One transport for every model call, enforced in CI; an ordered tool pipeline with declared risk and a fail-closed approval stage; a resolved-config endpoint
Server-side provider configuration with encrypted keys, a model registry with no hardcoded names, per-agent overrides, and a measured per-turn token profile
One registry of everything an agent can do: four execution kinds behind one contract, a catalogue you can read, organisation-authored skills, and a marketplace whose access rules are re-checked at dispatch
An MCP plane in both directions, connector operations bridged natively into it, per-caller authority instead of a service identity, and progressive disclosure that keeps the prompt bounded
A seven-step scan that turns a dataset into query patterns and business rules, four layers of stored knowledge including what agents learn in use, and hybrid retrieval fused by reciprocal rank
One audit trail for both kinds of actor, carrying model id, prompt hash, token counts, cost, latency and attempts - on the workflow path as well as the interactive one
Credit metering with no bypass, a per-employee monthly limit that denies by default, lazy period rollover, and suspension that refuses rather than falling back to a service identity
Agents run against storage inside the contour, on-prem and OpenAI-compatible providers are first-class, personal data has two separate rules, and self-hosting has a measured sizing answer
Twenty-four typed connector families with declared operation manifests, callable from a process step, a durable workflow or an AI agent - with encrypted credentials, replay-safe execution and one audit path
Declare an operation with its inputs, outputs and credentials, and it becomes a process step, a workflow step, an agent tool and an audited event without writing any of those four
An MCP endpoint that exposes the platform to external AI clients, and an MCP client that lets the platform call external servers - both under the caller's own authority
Dedicated identity and OAuth2 services instead of authentication written into the product, role-derived authority in place of static API keys, and on-behalf-of tokens between services
Functional roles from the session, object grants per resource with four access levels and four kinds of grantee, and roles an application declares that become grantable to your own people
Policies that bind a logical attribute to a value set for a set of subjects, injected as a filter into the query plan below any aggregation: decided per query, cached per decision, and fail-closed
Mask expressions annotated onto the plan's output columns - nulling, hashing, partial reveal or rounding to a bucket - resolved by priority and applied at execution instead of by the client
Schema-per-organisation instead of a discriminator column: the schema is set on the connection for the transaction, so a query that forgets everything still cannot cross an organisation boundary
Container images built per commit by CI, verified as a complete set before the commit counts as a release, pulled by the target which refuses to start a partial one - with each service reporting the commit it was built from
Capabilities are feature flags carried by a signed platform licence and a plan, and an organisation's effective set is the intersection - checked at the route, not in the interface
An application is a git repository of typed artifacts with a reconciler that materialises them, and the git is real: a clone and push transport, per-repo authorisation and no existence oracle
One trail across the platform for people and AI employees alike, carrying the actor, the operation, the outcome and - for model calls - the model, prompt hash, tokens and cost
