Adaptive User Interface through Language and Usage
Applications show everything to everyone, but each person uses only a small part.
Uitive builds each person's interface around the part they use: learned from their usage, changed when they ask in plain language, and always within the limits the application sets.


- 168 services become 8. The console keeps what this person said they need, and everything else stays a search away.
- Every change explains itself. Each one appears beside the console, with the reason it was made.
- The person stays in control. They can keep or revert each change, and anything Acme Cloud marks as essential can never be removed.
- 1 commandsets it up:
npx uitive init - 37 to 54 minfor coding agents to integrate it into 3 real applications
- 168 → 8services in Acme Cloud's console, after 1 sentence
- Any modelClaude, GPT, Gemini or local, or none: the built-in planner works offline
What people can ask for
Requests in plain language, and habits learned from use, each within the boundaries the application declares. The demo plans in your browser, without a model.
- Built-in planner
hide Bold
move Table to the top
compact
The toolbar or setting changes at once.
- Built-in planner
Open Table from More, session after session
Table joins the toolbar at the start of a later session.
- Model or built-in
I watch costs and budgets
What serves that goal comes forward, as in the picture above.
- Needs a model
make my home a morning check of what needs attention
A redesigned page, from the application's own blocks and data.
- Needs a model
put each customer's lifetime value beside their failed payments
A table joining 2 sources, read with the person's own permissions.
Safeguards
The application sets the limits, and policy checks every change against them.
Inside the contract
The application declares what may adapt. A plan that reaches outside it cannot even be expressed.
Required items stay
What the application marks as required is never hidden or removed.
Every action stays reachable
What is hidden is still there: in overflow, the palette or the standard view.
Nothing moves mid-task
Bigger changes wait for a safe moment, when a session starts.
Data changes ask first
Nothing changes data without the person's yes.
Every change can be undone
Each one is listed with its reason, and can be kept, reverted, exported or reset.
Start with npx uitive init
It installs the packages, writes a contract, a client and the bindings beside your code, and connects your coding agent through an MCP server. Every page keeps working unchanged from the first minute.
- Typed contracts, checked with zod
- Pages adapt as they are, with nothing to rewrite
- A planner that works offline, without a key
- An MCP server and a playbook for coding agents
import { action, defineApp, list } from '@plurid/uitive-core';
export const contract = defineApp({
id: 'notes',
description: 'A notes editor',
actions: {
bold: action({ label: 'Bold', description: 'Make the selection bold' }),
italic: action({ label: 'Italic', description: 'Make the selection italic' }),
link: action({ label: 'Link', description: 'Link the selection' }),
heading: action({ label: 'Heading', description: 'Turn the line into a heading' }),
share: action({ label: 'Share', description: 'Share the note' }),
quote: action({ label: 'Quote', description: 'Turn the paragraph into a quote' }),
code: action({ label: 'Code', description: 'Format the selection as code' }),
table: action({ label: 'Table', description: 'Insert a table' }),
},
surfaces: {
toolbar: list({
label: 'Toolbar',
description: 'Formatting and insertion, above the note',
items: ['bold', 'italic', 'link', 'heading', 'share', 'quote', 'code', 'table'],
capacity: 5,
required: ['share'],
reorderable: true,
}),
},
});import { createUitive, localStore } from '@plurid/uitive-core';
import { contract } from './contract.js';
// Learns from use and changes when asked;
// the person's interface is kept in this browser.
export const uitive = createUitive({
contract,
store: localStore('notes'),
});import { useState } from 'react';
import { useSurface } from '@plurid/uitive-react';
import { uitive } from './client.js';
/** The toolbar each person shaped: what fits, then the rest under More. */
export function Toolbar({ run }: { run(action: string): void }) {
const toolbar = useSurface(uitive, 'toolbar');
const [more, setMore] = useState(false);
return (
<div role="toolbar" aria-label="Formatting">
{toolbar.visible.map((item) => (
<button
key={item.id}
type="button"
onClick={() => {
uitive.record(item.id, { via: 'region', surface: 'toolbar' });
run(item.id);
}}
>
{item.label}
</button>
))}
{toolbar.overflow.length > 0 && (
<button type="button" aria-expanded={more} onClick={() => setMore(!more)}>
More
</button>
)}
{more && (
<div role="menu">
{toolbar.overflow.map((item) => (
<button
key={item.id}
type="button"
role="menuitem"
onClick={() => {
setMore(false);
uitive.record(item.id, { via: 'overflow', surface: 'toolbar' });
run(item.id);
}}
>
{item.label}
</button>
))}
</div>
)}
</div>
);
}- React
- Next.js
- Vue
- Lit
- GrainJS
- plain HTML
- Claude
- GPT
- Gemini
- local models
- built-in, offline
Open-source applications, integrated by coding agents
- Excalidrawdrawing · React 1917 actions, 1 list, 1 choice
- Medusa Admincommerce · React 18.3, @medusajs/ui3 sources, 39 actions (33 with effects), 9 routes, 2 pages, 1 list
- Gristspreadsheet · GrainJS, no React10 actions, 2 lists
How it works
Use is recorded as numbers, never content. A planner proposes changes over the contract's IDs, policy checks each one, and the person's definition keeps every change with its reason.
Get started
Set it up with 1 command, or try the demo first.