PIES Studio 1.9 is the release where the platform learned to run work for you, not just with you. Agents are posted on an environment and supervised from one feed, a delivery running a playbook step by step builds and changes applications, and the new Agentic AI manual shows every screen; every application gets enterprise sign-in without leaving the editor; and a template store puts 35 finished industry applications one click away. This page covers everything since 1.7, so it includes what 1.8 introduced.
If you are upgrading an installation, read Upgrading as well — the upgrade steps have not changed, but the notes below on sessions, templates and previews affect what you will see afterwards.
Agents, playbooks and deliveries
Agents arrived in 1.8. In 1.9 the whole area was rebuilt around three kinds of work — a delivery changes an application, an errand does one thing to a running one, a post stands watch on an environment — with three entries under Agents in the sidebar (Agents, Playbooks, Activity), one door into all of it, and one feed where every kind reports.
- The Agentic AI manual is new. The Agentic AI manual walks through every agent screen with pictures: New agent, Configure field by field, posting, playbooks, the delivery control panel, errands, approvals, templates with test data, and troubleshooting. The Agents page is the concepts in brief.
- Design in the editor, operate on the deployment. The editor's Build → Agents holds an app's agent designs: brief, access, triggers, guardrails — with no Post, Pause or Fire there. The deployment page's Agents tab is where you post an agent, run an errand, pause, resume and fire. The Studio sidebar's Agents lists every post across apps.
- New agent is Who, Brief, Freedom. From inside an app, Who is already answered and it walks two steps. Freedom sets autonomy, the access group it runs as, its reach and when it runs. There is no Role picker: the role on the roster is worked out from the agent's reach and triggers. The Build or change an app card opens Start work for a delivery.
- Posts per environment. Posting freezes a snapshot of the brief, tools and guardrails, takes an agent seat and arms the triggers. The same agent can be posted on several environments at once, each post independent. Brief, access, triggers and guardrails reach a running agent only when you Post again; pause, resume, tool auto-allow and memory apply at once. Firing one post stops only that environment's runs; a post cannot be placed on a preview.
- Autonomy is Supervised, Autonomous or Locked down. Supervised (the default) parks writes for approval, Autonomous never asks, Locked down parks every call. Who is asked sends a parked call to whoever posted it, the app's operators, or named people.
- When nobody answers, the run carries on. A parked call waits 5 minutes for Run now and an hour for scheduled runs, events, webhooks and errands, unless the agent sets its own window. Unanswered, the change is skipped, the agent is told, and the report ends "1 change was not approved, so it was not made."
- Approvals you can read before you answer. An approval card shows who started the run, the function or query with its parameters, the agent's reason, the steps so far and a link to the run. Allow, Deny with a note the agent reads, Allow this for the rest of the run, or Always allow. Every decision is written into the run, signed.
- Webhooks and app events per post. An app event runs within seconds when a deployment or build fails or a bug is reported from the preview. A webhook's signing secret is issued at the first post and kept by Post again; its endpoint runs every unpaused post of the agent, and
?deployment_id= calls one environment's post.
- Runs as an access group. An app agent acts as one of your app's access groups, and the app enforces that group's permissions — including which tables it may read directly. Rows it writes are signed PIES Agent · <group>. Each deployment issues one credential per access group.
- Errands are new. One action on a running application, one run, nothing standing — started from Start work or Run an errand on a deployment. An errand always runs Supervised; approvals go to you and the environment's operations approvers, and the first answer decides.
- Playbooks have their own page, and every workspace starts with three. Rules plus ordered steps, each with a role, tools, a model tier of Small / Mid / Strong and a per-card toggle. Full delivery route, One builder and a verifier and Fixer are marked Stock. The page has a workspace bar, search, a Stock / Made here filter, sorting, and Start delivery on every row.
- A fourth stock playbook, the Self-improvement loop, needs no brief. Start it on a built application and it audits the app, files each finding as a card with an exact probe, fixes and verifies each card, and leaves a GUARD block on every closed one. The next run re-probes those guards first, so what it checks only grows, and a Reflect step ends each run with a scorecard card and up to three proposals for you to apply.
- Deliveries run their playbook, in a delivery control panel. Each step is a worker in its own context, handing over through the board's cards. The control panel shows the header and status, brief and board, the Route of steps, a Live trace with a box to steer the running step, and Pause, Resume, Stop, Retry, Skip, Roll back and Delete. Status is Running, Paused, Awaiting decision, Stopped, Done or Failed — a delivery you stop is saved as Stopped, not Failed.
- Every run that ends short says why. Stopped by you, Replaced by a newer run, Ran out of time, Waited for an answer and gave up, Interrupted by a restart, Environment unreachable from the platform, or the last tool error. After a restart an interrupted delivery offers Run again.
- Budgets and long runs. Iterations, tokens and minutes per run, and monthly tokens; at its monthly limit an agent is not started at all. At three quarters of its iteration budget a run compacts its history and continues, up to three times.
- Templates come with agents and test data. Every system template installs an agent pack and sample data shaped so the agents find something on their first run; the gallery's What the agents will find names the rows. The agents are posted for you when the app is deployed.
- Publishing keeps your data. Changing the data model and publishing never deletes data or reloads sample rows over it. Removed tables and columns stay in the database and are listed under Your data was kept; a type change that could lose data is refused.
- Building a preview warns before it resets the data. A preview Build reloads the preview database from your Data tab rows, so records added or changed in the preview are lost. Build now asks first — This resets preview data to your Data tab rows — with Cancel, Build and Don't show again. Don't show again applies to that application only, and Show dismissed warnings again on your Profile brings the question back. Building for a deployment does not ask, and publishing keeps data as before.
- Activity is the one feed. It replaced the Comm Center, the inbox drawer and agent notifications: Needs you, Running, Today, Failed and Everything, filterable by kind.
- The API keeps the old word. Playbook endpoints are still
/agents/squads/… and the rules field is still charter on the wire. If you script against PIES Studio, nothing you wrote for 1.8 changes.
See the Agentic AI manual, the Agents page and chapter 10 of the user manual.
Users & Access — sign-in for every application
Authentication is now configured once on the application, in Users & Access, and every deployment inherits it; an environment can override which methods it offers.
- Sign-in methods: password, Sign in with PIES Studio, Microsoft, Google, Apple, OpenID Connect and SAML — as cards, in a guided, numbered setup.
- Sign-in policy: SSO-only, allowed email domains, and whether self-registration is open and which group a new account lands in (never an administrator group by default).
- Session policy: session length, single logout, two-step verification for password sign-in, and group-mapping rules per provider so an identity provider's claims decide the access group.
- Set Password is a designed screen like Login and Register; forgot-password sends a real email that opens it. Previews and builds carry an email server so this works before deployment. The Forgot Password screen tells you what happened when you press Send: it asks for an email address if the box is empty, and shows a red message when the email is not registered or the application has no email server set up, or a green one when the reset email was sent.
- No default administrator password. You set the application's administrator password in Users & Access; Open as administrator on the deployment page signs you into a running application without it.
- Invite user under Users & Access gives someone access to a deployed application: pick their email, access group and deployment, and they receive an email to choose a password. The App users list shows who has access to each deployment.
- Switch role in a running application. A user in two or more access groups gets a role picker beside their name in live preview and deployed applications: All roles, or one group at a time. The application narrows screens, menus, functions and data to the chosen group on the server, and signing in again returns to all roles.
- A built-in Public access group lets guest users reach data, so a storefront or a public catalogue can exist.
Access model — teams, roles and operations
- Teams and roles you can actually change: roles are presets of capabilities, and a person's capabilities are their role plus explicit grants. Invite people as a role, not with an administrator checkbox, and invite people who do not have an account yet.
- Operations grants. An Operations panel on the deployment says who runs an application; hand operations over in one act, and the people who run an application can read it without a build seat. Agents inherit their application's operations grants, and their approvals route to whoever runs the app.
- The navigation follows your capabilities: what you cannot do is not shown.
Template store
The template gallery became a store: browse by category, open a template to see screenshots, What's inside (screens, tables, roles, functions, documents) and About, and install. Every bundled agent is an operator, posted on an environment of the installed application when you deploy it, never a builder — and each template's sample data is shaped so those agents find something on their first run; dates the agents judge against are set relative to the day you install, so a "due next week" row never goes stale. The catalogue is exactly what ships: a renamed or duplicated entry (an older "Courier & Delivery" beside "Courier and Delivery") is retired on start-up, and applications already installed from it are untouched. Thirty-five finished industry applications ship with the platform — hospitality, fitness, beauty, trades, professional services, education, events, logistics, telco site monitoring and field events, visitor management, retail banking analytics and more — each with sample data and, where useful, a bundled agent pack that is installed with it. Sample rows with no value are stored as empty, not as blank text, so they never link to a record by accident; and in Telco Site Monitoring and Alarm Correlation an incident added without an IM number is given the next one automatically (IM numbers are required and unique). An application installed from an earlier version keeps its data until you install the template again. A template that needs an external system finishes with its own connect flow and offers the integrations you have already saved. The store opens instantly and remembers the gallery for the session.
Navigation and the workspace
- The navigation is two layers grouped by what you are doing: Build (Applications, Library), Agents (Agents, Activity), and the rest; pinning the rail keeps both visible inside an application, and Agents is one click away from inside an app.
- Workspaces moved into the applications page as a pill bar: one row at any scale, application counts on each pill, overflow behind a searchable +N more. Each application shows how many agents it carries.
- The explorer colours objects by kind, demotes folders and draws indent guides; dropping onto a folder nests into it.
- Getting started: a first-login tour of the workspace and the editor, a Getting Started checklist that ticks itself off as you create, model, build and run, and Help → User Manual links that open the matching chapter of this documentation. Press ? for shortcuts.
Application chrome, theming and the home page
- Header Builder. The header's brand column now matches the sidebar exactly; text colour, divider colour and divider thickness are editable, with automatic defaults. The Menu tab previews the header with the same renderer as the canvas, and a dark header gets a logo tile.
- A new application starts with a Home Page — a welcome band, three get-started cards and a PIES AI tip — and opens on it with the canvas fitted.
- The generated React application now matches the IDE canvas — one dark surface, sidebar brand block, page-title header, quieter menu — so what you design is what you ship.
- Chatbot appearance for the in-app assistant is a form with a live preview under the application's settings, and the widget follows the app's theme tokens. Templates ship with the chatbot enabled. The chatbot looks each thing up in your data once and then answers with the result — asked how many records there are, it replies with the number instead of describing the lookups it used.
In-app notifications
A Notify User step in the Comms group sends an in-app notification — title, body, parameters and actions, with variables interpolated — to users of the generated application, which now has a notifications API and a header bell whose click routes on the notification's id.
Building, previewing and deploying
- Previews start faster: a shared dependency cache is cloned into each new preview instead of a cold install; dependency installation has its own clock and a timeout is never mistaken for corruption.
- Previews are capped and admitted: every preview container is limited in memory, CPU and processes, and a preview host refuses new previews past its capacity rather than degrading the ones already running.
- Moving between screens in a React preview is fast. Once you have stopped editing an application for about a minute and a half, its preview switches by itself to an optimised build, so menu items, table rows, buttons and Back open the next screen in a fraction of a second. Open preview tabs keep working across the switch. Your next edit puts the preview back in editing mode, where screens can take longer to open until it settles again; this takes one to three minutes depending on the application.
- Deployments say what they are serving. An active deployment on a stale build carries an amber Serving previous version badge; a failed publish that keeps the old version up no longer looks healthy. Deployments have an Agents tab, and hosted deployments expose container logs and stats.
- The data model is validated during the build, not at deploy; foreign keys index their parent column; a dropdown whose option columns do not resolve refuses to generate.
- Mobile builds survive restarts and reach the backend from a real phone; the Show Message step honours the editor's custom input on React and Flutter alike. A Show Message of type success or info now appears as a short notice in the bottom-right corner that clears itself after about three seconds, so the next step (a Navigate after Save, for example) runs straight away; error, warning and untyped messages still open a dialog you close.
Data and external sources
- An external source with no credentials prompts for them, and supplying them finishes the source rather than creating a second copy.
- Joins work against a schema-qualified external source; the schema stays recoverable when a source is disconnected.
- Chart filters reject an unknown operator instead of silently dropping it.
AI governance
- Heavy work — screen authoring, architecture — is routed to the strongest model your policy allows; that routing is policy data, not something the engine decides on its own.
- Governed calls are attributed to the agent that made them, embeddings no longer bypass governance, and one subscription is one governance regardless of how the tenant is addressed.
- Scanned PDFs uploaded to the Knowledge Base or as artefacts are read by Claude only when your AI policy allows it; every attempt is audited, and under Air-Gapped the document is refused rather than sent out.
- Every AI build now runs on the current build engine (plan, build, then check). The Build engine choice in AI Settings is gone: the page shows Build engine: v2 for reference, and an earlier setting that picked the previous engine is ignored. Builds are governed the same way throughout: the same request selects the same model, is redacted the same way and writes the same audit record, and Claude calls record their token usage so they count towards token budgets.
- A policy's description on the Policies list now says what the policy actually does — which requests it matches, the preferred and heavy-work models, the fallback and the allowed providers — built from its own settings. A description you wrote yourself is kept. The Default Balanced template's description was corrected to match: it no longer mentions on-premises routing or a separate day-to-day model.
- Each enabled policy on the Policies list shows where its calls actually went — Resolved: provider / model (N of last M calls), taken from its recent audit records — with one sentence saying why: the rule that matched, which allowed provider answered, and why the preferred model was skipped (its provider is not allowed, has no key or is not served) or why calls went elsewhere. The line is highlighted when it differs from the preferred model. Problems the policy checker finds are listed in the policy's own row, each with a Fix link that opens the editor.
- In the policy editor, Preferred model offers only models from the providers ticked under Allowed providers; other models are greyed out with a hint to tick their provider, and picking a model no longer adds its provider for you. The model the policy actually resolves to, and why, is shown beside it.
- The policy Test Console lets an administrator try a request against the policy stack and see which rule answered.
- Personal-data detection now recognises international and local phone formats (such as
+61 412 345 678, (02) 9876 5432 and +44 20 7946 0958), Australian Tax File Numbers and Medicare numbers (with their check digits), and labelled dates of birth. Requests containing them meet your personal-data policy rules and are masked as [REDACTED:phone], [REDACTED:tfn], [REDACTED:medicare] or [REDACTED:dob]; ordinary dates and counts are left alone.
- The audit log records a request as redacted only when a policy actually masked it; a request whose policy has no redaction set is recorded as allowed.
- A question in the AI chat that says not to change the app (for example "Do not change the app") is answered in the chat, even when its wording mentions things like cards or phones, instead of starting a screen build.
- Asking the AI for an empty screen, or a screen with just a heading, builds exactly that: one heading section, without the getting-started cards it adds to landing pages on apps that have no tables yet.
For administrators
- Sessions survive restarts. Signing keys are stored in the platform database, so replicas share one key set and a restart no longer signs everyone out.
- Templates ship in the image and are seeded on first start, so a fresh installation has the full catalogue without a network fetch.
- Applications with timestamps written by older tools are repaired on start-up; an application that fails to load now logs the real reason instead of not found.
- Deleting an application deletes its agents; an application belongs to the tenant in the session, never the one in the URL.
Fixed since 1.7
Among the tickets closed from the preview programme:
- Table default length, database menu not closing, and the function error tab.
- Add Record did nothing on a new or template table.
- A phantom duplicate section header in the explorer after an AI build.
- Dropping an item onto a folder reordered it as a sibling instead of nesting it.
- The configure popup loaded functions without their real context; its dropdowns render above the dialog and the action-type selection registers.
- Dragging a panel blanked the canvas; a widget resize can no longer store an invalid size.
- Saving a code block with non-Latin characters.
- The PIES AI panel opens regardless of module connection status.
- Radio labels in the builder honour the authored font colour, as the preview does.
- Document template sections keep their identity when reordered; the Generate Document step has an input-parameters editor. A table section fed by a Find Records result now prints every row (it printed only its header), and
$now or $today in a document's text prints today's date instead of the literal word.
- A published widget pending review can be withdrawn.
- A just-saved environment was invisible on the Deploy tab until reload.
Updates since release (October 2026)
Hobby, the free desktop
- Installers for macOS (Apple silicon and Intel), Windows (64-bit; the installer is not code-signed yet) and Linux (
.deb and AppImage). No sign-up: the first launch creates a local account.
- Fonts, icons and the full template gallery ship inside the download, so the editor renders and the gallery is full with no network.
- The free plan is enforced by the local services, not just the editor: hosting and deployment, boards, mobile builds, team invites and agent hosting answer This needs a paid PIES plan, while downloading the generated source code is free, and every build uses the default stack (MySQL, Go, React), web only. Team and server features in Admin show a padlock; server-only settings are left out. See Hobby.
- Hobby's AI is PIES Private AI Micro, free and running on your machine. AI Settings on Hobby shows only Micro (on/off, one-time download, status and requirements); cloud models and PIES Private AI Lite and Ultra are shown as Enterprise / PIES Cloud cards with no key fields, and work when the desktop is connected to an Enterprise server or PIES Cloud. The chat chip reads PIES Private AI Micro, and asking for a cloud model offline explains how to get one instead of asking for a key. See Hobby.
- The local models have one name and two sizes: PIES Private AI Lite (a 96 GB Apple Silicon Mac or one 94 GB GPU) and PIES Private AI Ultra (a 256 GB GPU server). The AI chat chip, the build receipt and AI Settings all show these names, and the chip now fits its row with the full text in its tooltip. A policy that names a retired model still works and shows as PIES Private AI (legacy). See Private AI.
Agents
- A Record change trigger runs an agent when rows in a table of the deployed app are created or updated, optionally filtered by one column.
- The New agent wizard and the Post dialog say up front when the app is not deployed yet and offer Deploy the app; Run now explains why it is disabled until the agent is posted. With a single access group, Runs as is picked for you.
- An approval waits 5 minutes for Run now and an hour for scheduled runs, events, webhooks and errands, and the wait no longer counts against the run's minutes budget.
- Activity folds repeated items from one agent into one row, dismisses in bulk, and shows how many records it lists. Playbooks → All workspaces groups the stock copies by name. The Agents Map captions clusters with app names and post counts.
PIES AI and governance
- PIES AI → Memory lists what PIES AI remembers — Organisation, App and Agent notes — with who wrote each and when; administrators can add, edit, delete and promote notes. Organisation notes reach every build, Studio AI answer and agent run in the organisation. The page shows how many notes each scope holds, filters by scope tab and search, and marks each note's scope with a colour, in light and dark themes.
- Memory notes are masked and versioned. Every Organisation, App and Agent note goes through the same personal-data classification and masking as the Knowledge Base before it is saved — an email or card number is stored as
[REDACTED:email] or [REDACTED:credit_card], and a note is not saved if the check cannot run. Each edit or delete keeps the earlier text with its author and time: History on a note offers Restore, and Recently deleted brings a deleted note back.
- A data-only request builds only the data. Ask PIES AI for just a table — "add a table named Notes with a text column title, nothing else", "data model only", "no screens" — and it adds the table without list, form or detail screens, functions, events or sample rows. Delivery steps that word their own data-only change are read the same way, so a verifier no longer finds screens nobody asked for. Name a screen, page, form or dashboard and the full build runs as before.
- Governance policies match every class detected in a request, so a card number in an app classified PII still meets PCI rules.
- Knowledge Base text is classified and masked at upload, every change is audited, and opening a source shows its real classification, scope and origin.
- Knowledge Base search no longer needs an OpenAI key: without one, documents are indexed by a built-in local embedder that never leaves your network, so search keeps working under Air-Gapped. It matches on shared wording rather than meaning.
- The AI audit log names the user and the app instead of showing ids; the policy editor picks applications by name.
- PIES Private AI is a Preview in 1.9 — great for chat and simple builds, with larger redesigns still improving — and it carries a Preview badge in AI Settings, on the Private LLM tab and in the model pickers. The recommended model is Claude Opus with your own Anthropic key, marked Recommended in AI Settings, in Force one model and in a policy's preferred-model picker. See PIES Private AI.
- AI Settings shows each provider key's real health (Key rejected, Out of credit, Rate limited), and administrators see a banner while a provider that a governance policy actually routes to is out of credit; a key no policy uses does not raise it.
- Force one model accepts only a model whose provider is connected. Choosing a model from a provider with no API key (or Azure without its endpoint) is refused with <Provider> is not connected. Add its API key under Providers before choosing <model>. and the active model is left unchanged, so every AI turn no longer fails against a provider you never set up.
- AI-built screens lay out KPI cards in one row of up to four, even when PIES AI adds several groups at once, use the full width of the canvas for charts, tables and other content, place sign-in, sign-up and password-reset forms in a centred card about 560 pixels wide, place add and edit forms in a centred card about 720 pixels wide with Cancel and Save inside it and a screen only as tall as the form, and pair charts on a shared content grid, take colours from the app's theme, no longer add a second button with the same label, and no longer put "Ready to get started?" panels or a stray "or" under an add or edit form — the form's own Cancel and Save are its only actions.
- Add and View screens generated from a table with only a few columns sit in a narrower card, and a form of three fields or fewer stacks its fields in one column, instead of spreading them in half-width columns across the full width with an empty slot beside the last field and a large blank area below.
- In a generated application's edit form, clearing a text field and pressing Save now blanks the stored value. Before, an emptied field was treated as unchanged and the old value stayed (a settings banner, for example, could not be removed). Fields the form does not include are still left as they are, and an empty field on an add form still gets the column's default. Regenerate or rebuild the application to pick this up.
- Text colours on AI-built screens are checked for readability against your app's theme on every save, whichever model answered and however the screen was changed (new screen, whole-app build, inline edit, style change or widget patch), so white text on a white page is saved in a readable colour instead. This includes the code of custom widgets PIES AI writes: a text colour that would not show on the card or header behind it (grey Due: dates on a dark card header, for example) is saved in a readable colour, and colours that already read are kept.
- The readability check also understands colours given as theme variables, so field labels on a dark form PIES AI builds are saved in a readable colour instead of dark text on a dark card. On the editor canvas, a table whose header colour was set with the
header-color style now shows that header fill, as the built application does, instead of a white header under light header text.
- A theme PIES AI generates is saved as a theme of its own, and its sidebar is always readable: when the requested sidebar text would not show on the sidebar background, the sidebar takes the theme's darker brand colour. Apps whose AI theme was saved earlier keep their old sidebar until the theme is saved again (re-run the theme prompt or save it in Themes).
- Asking PIES AI to add a button to an existing screen ("Add a button labelled Greet to the home page") now adds and saves the button, instead of rejecting the edit with nothing changed.
- Asking PIES AI what a button should do when it is clicked ("When Greet is clicked show a message saying Hello") now adds a click event to that button that shows the message, and leaves the rest of the screen as it was. If the screen has no such button, the receipt says the event was not applied, instead of rebuilding the page and reporting success.
- Asking PIES AI to make a screen the home page ("Add a Dashboard page as the home screen") now makes it the screen the application opens on, and the reply says so only when it was set.
- Asking PIES AI for a dashboard ("KPI cards, alarms by severity pie and incidents table") builds it from the stock KPI card, chart and table widgets, which follow your theme, instead of writing custom widgets; a custom widget is written only when you ask for one. A build turn can no longer empty a screen's widgets unless you asked to clear it. An AI-built dashboard opens with a compact page header instead of a tall landing-page banner, and PIES AI no longer stacks a second banner on a screen that already has a title band, so there are no large empty bands above or below your content.
- KPI cards PIES AI builds count the right rows. A card whose figure lives in a different table from the rest of the row (for example Problems to Confirm adding up a count kept on grouped alarms) is now built on that table instead of being left out, and a filter such as not Acknowledged counts every row that is not Acknowledged instead of none. Screens built before this keep their saved cards; ask PIES AI to rebuild the KPI row to pick it up.
- Asking PIES AI for a whole game or app built around a coded view ("Build a Tetris game app … the game board as a custom widget") places exactly one board custom widget on the gameplay screen it planned, without list, chart or form scaffolding beside it. The board sits directly under the page header, full width and centred, with its height fitted to the game grid, and the rest of the screen moves down below it, so the game is the first thing you see instead of a small board at the bottom of the page. Rebuilding never adds a second board to a screen that already has one.
- A data custom widget PIES AI writes over several tables ("a gauge showing the percentage of sites that have at least one Critical alarm, using the sites and alarms tables, and add it to the Dashboard screen") is loaded with the rows of every table it names and links them on columns those tables really have, so the gauge shows the real figure instead of always 0%. Gauge, ring and progress tracks are drawn in the theme's border colour, so they stay visible on dark themes.
- Asking PIES AI for a widget such as a star rating ("Add a star rating widget to the Home Page") now searches the widget library first, instead of designing a new page around the request; when nothing in the library fits, PIES AI writes a custom widget and places it on the screen.
- Asking PIES AI to delete a screen or table by its name alone ("delete zudio_test", "remove Thematic") deletes the screen, or else the table, with exactly that name (capitals do not matter), the same as "delete screen thematic". When nothing has that name, PIES AI replies that it couldn't find a screen or table called that and changes nothing.
- A chat request that names no screen ("add a text box") is made on the screen open in the editor instead of PIES AI asking which screen you mean, and "this" or "it" means the widget you have selected.
- The build receipt lists what the run changed and no longer mentions lookups PIES AI retried and recovered from on its own.
- A PIES AI build cut off by a service restart now ends as an interrupted turn with pies-ai restarted while this build was running. Click Continue to resume. and offers Continue, instead of a finished turn saying no changes were made. See Error reference.
- When you send the first message of a new PIES AI chat, it appears in the chat and the message box clears as soon as you press Enter, with a ⏳ Sending… bubble while the chat is created, instead of the text staying in the box for several seconds when the platform is busy.
- After a screen change the build receipt is built from the saved screen: it lists the widgets Saved on screen and flags any widget the summary names that is not there, so a summary can no longer claim widgets that were never saved. The receipt also re-checks text readability on the saved screen and reports Design check failed: illegible text when text would not show against its background, and a redesign always updates the screen's last-saved time.
- A screen edit that would leave an empty card, container or banner, a placeholder-only widget or a default Page title header is not saved: PIES AI is told what was empty and fills it in or removes it, so a redesign no longer reports success on a hollow page.
- Landing pages and screen redesigns are built from a set of ready-made page sections (a hero banner, a split hero with the copy on one side and a picture on the other, feature cards, a call to action, a table page, a KPI row, a compact band of headline figures, a grid of two to four charts laid out two per row, each in its own titled card, and a map with a location list) that take their colours from your theme, instead of being styled freehand, so they look consistent whichever model does the design. A split hero shows an image from your app's media library when you name one; otherwise it draws an illustration in your theme's colours, so an offline installation never shows a broken picture. A row of only one or two feature cards (for example quick links on an app with a single other screen) keeps each card about a third of the page wide, instead of one card stretched across the full width with a blank area beside it.
- A whole app PIES AI builds now gets a look that fits what it is for. After the plan, PIES AI picks one of seven design presets — Clinical, Vibrant, Corporate, Warm, Fresh, Elegant or Industrial (dark) — and saves it as the app's theme (Design: Vibrant, for example), so every screen of the app matches and a clinic app no longer looks like an events app. The preset sets the colours and type; PIES AI never chooses colours freehand, and every preset passes the readability check. Asking for one screen in a style saves the preset as the app's theme in the same way, so the screen's colours come from the theme rather than fixed colour values, and form Save and Cancel buttons follow it. An app that already has a theme you made keeps it. Asking for soft pastel colours or for purple (restyle the page in purple; violet, lilac, lavender and plum work too) switches the app to the Design: Pastel or Design: Purple look in place of the one PIES AI picked. Asking for green or your brand green (green and white) switches it to Design: Green, green #2E7D32 on white. New page layouts arrive with it: a split panel (a list beside a summary chart) and a sectioned dashboard grouped under Overview, Insights and Records.
- Asking PIES AI to add to a screen it built ("add a chart of tasks by status", "add a KPI row") adds the new section where you say — at the top, at the bottom, or above or below an existing section — and moves what is below it down, so nothing overlaps. "Put the table and the chart side by side" places the two in one row. Each change saves a new version of the screen you can rewind. Layout requests such as make this work well on a phone, moving or resizing a section are now carried out as a redesign of the open screen, which PIES AI re-lays out and saves as a new version, instead of a reply that nothing was changed.
- PIES AI no longer adds a second copy of a table to a screen that already lists that table, and a table it places lower on a screen is moved up under the content above it, so a list or form screen no longer shows a duplicate grid or a large blank band. Screens built with an earlier version keep their widgets until you ask PIES AI to rebuild them.
- In the running application, a table that shows all its rows on the first page now ends just below its last row and its footer, and the widgets below it move up, instead of leaving a large empty area inside the table. When more rows arrive than fit on one page, the table returns to its full height with the pager; a table beside a chart keeps the height the chart needs. The pager's row count stays readable on dark table backgrounds.
- A screen PIES AI builds no longer shows the same button twice: when two sections would each add a button with the same label, the screen keeps one. A table PIES AI builds without any row actions now gets a View row action that opens the record on the table's Detail screen (for a Customers table, Customer Detail), when the app has that screen.
- Ask PIES AI for a map of a table that has latitude and longitude columns, such as your sites, and it builds a map with a marker for each row in your theme's primary colour, with a list of the same locations beneath it. A table without coordinates gets the location list only, never an empty map.
- Ask PIES AI for a filter bar over a table and it adds a bar with one dropdown per filter column, such as status or category. Picking a value narrows the table to the rows with that value, and All shows every row again, in both React and Angular apps. A search or filters section PIES AI plans for a screen with a table now becomes a filter bar on that table, instead of a heading-and-text band with no control in it; a section with a button that opens another screen stays as it is.
- Tables open without the row of filter boxes under the header and without a labelled Columns button. A filter icon in the table's toolbar shows the filter boxes when you need them; the row stays open while any filter has a value, and when it is closed with filters still set the icon shows how many (for example Filters (1)). Clear the filters and close it to hide the row again. Choosing columns is now an icon menu in the same toolbar. To keep the filter row always open on a table, set its
filterRow constraint to open; turning off filtering or column choosing still removes them entirely. The editor canvas shows tables the same way, in light and dark themes. This applies to React applications.
- A table can open already sorted. Give it a default sort column and direction ("list readings newest first by point date") and the built application opens the table in that order, with the arrow on that column's header; clicking a header still re-sorts as before. Without a default sort, a table opens in the order the rows were added. This applies to React applications.
- A table can be edited in place. Set its
editable constraint and choose a save function (saveFunction), and users can change cells directly in the built application: each column gets a text, number, date, dropdown or checkbox editor, and a column can be required or given a minimum and maximum. Changed cells are highlighted, and Save changes (2) calls the save function once for each changed row, with only those rows and their edits; set saveMode to bulk to call it once with all the changed rows. A row that fails shows its error and stays pending, Undo edits discards what has not been saved, and Add row (allowAddRow, with an optional addFunction) adds a blank row. For now these settings are made in the screen's JSON; an Editing section in the table properties is coming. This applies to React applications.
- Ask PIES AI to colour code a table by a column ("colour code the requests by priority") and each value in that column is shown in bold, in its own readable colour: urgent and high in red, medium and pending in amber, low and done in green, open in blue. The colours also show on the editor canvas, which no longer drops colour rules saved on a table column.
- A detail screen PIES AI builds for one record, such as a contact or a ticket, now loads that record from the id in the page address and shows its values in the built app, instead of a dash for every value. Detail screens built with an earlier version keep showing dashes until you ask PIES AI to rebuild them.
- A detail screen PIES AI builds for one record now opens with a header and a Back to button that returns to the list (for example Back to Clients), then the record card. It no longer adds a table, KPI cards or a chart for the whole table under the record.
- When you ask PIES AI for a friendly message for when there is nothing to show ("No tasks yet"), it becomes the table's empty message, shown in the built application only while the table has no rows, instead of a band that stays on screen above a populated table. The editor canvas still shows No data yet for an empty table. On a screen without a table, or when the message comes with a button ("Add your first task"), PIES AI builds a centred empty-state card with a dashed border in your theme's colours instead.
- A list of records in a built application, such as a low-stock or open-orders list, now shows a centred No data yet in the list's own text colour when no records match, instead of an empty box. Apps generated with an earlier version show it after they are built again.
- Asking PIES AI to rename a table now renames it in place: the table keeps its columns and rows. When the table you name does not exist, nothing is saved and PIES AI says it was not found, instead of creating a new table under the new name.
- Asking PIES AI to rename a screen, an event or a function ("rename the screen Orders to Sales") now renames it in place. A renamed screen keeps its place in the menu and explorer, an event keeps the buttons bound to it, and every step that calls a renamed function is updated to the new name. If the name you give does not exist, or the new name is already taken, nothing is changed and PIES AI says why. Before, a screen could be left unchanged or rebuilt as a new screen, a function was copied under the new name beside the old one, and an event rename was rejected.
- PIES AI now keeps to edit existing items only. When you ask it not to create any table, screen or function ("no new tables", "existing items only"), or ask it to rename something or fix the casing of names, it changes only what is already in the app; anything new it tries to add is refused and it edits the existing table, screen or function instead. Before, such a request could still add a new screen or save lowercase copies of your tables.
- Asking PIES AI to delete backend functions ("Delete these three backend functions … Change nothing else") now deletes them, and the receipt lists each one deleted; a version of the app is saved first, so the deletion can be rewound. Before, PIES AI kept the functions as disabled stubs and reported them as updated.
- Asking PIES AI for an event now builds it directly: a button that opens another screen (with the record's id), asks for confirmation before it acts, goes back, sets a field or shows a message, and a screen that runs a function when it opens. Each is saved as a working event, and anything that could not be built is named in the receipt instead of being guessed.
- Asking PIES AI for a data model on its own ("create a data model for a clinic") now builds the tables, columns and foreign keys directly in one step, using an id key on every table, and the receipt lists what was saved. Data-model and event requests finish faster and use far fewer tokens than before.
- Asking PIES AI to add a field to an existing table ("add a priority field (Low, Medium, High) to jobs and a chart of open jobs by priority") now adds the column to that table first, fills it in on the rows already stored, and then builds any chart or screen you asked for over the new column. Before, such a request could build only a new screen with placeholder cards and leave the table unchanged. Asks to remove or rename a column, or to add a search or filter box, are not treated as new fields.
- When the model a policy chose is busy or rate-limited, PIES AI waits and retries that model for up to about a minute before handing the request to the policy's fallback model, so a design request is not quietly finished by a smaller model. The model chip still names the model that answered.
- PIES Private AI: the Private LLM card shows the seed training data and can refresh it, and every fine-tuning job trains on it unless you opt out. See PIES Private AI.
- PIES Private AI builds faster: each build, inline edit or chat request shows your private model only the tools that kind of request needs (a screen redesign sends roughly a quarter of the earlier prompt), and the model can ask for another group of tools mid-build when it needs one. Cloud providers are unchanged.
- A whole app built by one PIES AI agent no longer reports Build complete after saving only tables. When the agent adds tables but no screens, PIES AI runs one more pass for list, add and edit screens over them; if it still adds none, the build ends with Build finished — added N table(s) but no screens. See Error reference.
- PIES Private AI Home screens look finished: a hero no longer repeats the starter Home page's placeholder sentence, and a table the model asked for with a single column shows the table's first four columns, the requested one first.
- AI-built screens come out complete with every model: the AI cannot finish a build while a screen it created has only a title band and no content, a table never shows the same column twice, and a page title the AI did not position is placed at the top of the screen rather than below the content.
- A table PIES AI builds now shows its real column headers and values when the model lists the columns by name only, instead of undefined in every header and cell. Screens built with an earlier version keep their table until you ask PIES AI to rebuild it.
- PIES Private AI edits change the screen in place: asking it to change a chart's type updates that chart instead of adding a second heading and chart below the table.
- Asking PIES AI to redesign a screen in an application that has no tables yet builds a content-only page (a hero, feature cards and a call to action pointing you to Build → Database) instead of inventing tables that do not exist and saving nothing. The build receipt says The app has no tables yet, so I built a content-only page; add a data model to get tables/charts.
- A redesign keeps the screen's purpose, with every model. Asking PIES AI to redesign this screen on a Login, Register, Forgot Password or Set Password screen gives it a better layout (a hero, the sign-in form, a call to action) but never adds tables, KPI cards or charts, and the sign-in form is not tied to one of your tables. Redesigning any other screen keeps the kinds of sections already on it and adds data sections only when you ask for them (add a chart of…). A form tied to a table that names no fields shows up to eight key fields instead of every column, and every section of an AI-built screen lines up to the same page width.
- AI-built screens look more finished. KPI cards get an icon, a coloured accent bar and, when the table has a date column, the change against the previous 30 days; charts get axis titles and a legend, and a chart on its own sits in a titled panel; tables get search, filters, column choice and sorting; a landing page hero gets an illustration in your theme's colours. A single screen built on its own now picks a design style the same way a whole app does, with every model including PIES Private AI, and a theme you made yourself is kept.
- Asking PIES AI to add icons to make the page easier to scan now puts an icon on every feature card, with every model; before, some models left the cards without icons.
- PIES AI builds the buttons and columns you name. A request such as a table of data sources (name, kind, status, last sync) and buttons Test Connection and Sync Source now gets every listed column and every named button; if the first pass leaves one out, PIES AI adds it before the build ends.
- PIES Private AI agents can answer in plain words: an agent run whose first reply answers the question without a tool now finishes with that answer, as on a cloud model, instead of being pushed into a tool call and ending paused. A reply that only describes a plan is still sent back to act.
Building and running
- Generated apps on tablets. Between 768 and 1279 px wide, the side menu now starts collapsed to its icons, so the screen keeps full-size text and fits the width instead of shrinking beside the menu. People can expand the menu there; that choice is not remembered, so the next visit at that width starts collapsed again. Collapsing the menu on a desktop works as before and is still remembered. If a screen still would not fit, it stays at least 80% of its designed size and scrolls sideways rather than shrinking further.
- A table whose header text colour matches its header background no longer shows a blank bar: the column names are drawn near-white on a dark header or near-black on a light one. Rebuild the preview to pick this up.
- In a React application, KPI card numbers and labels and text-widget text whose colour would be unreadable on the card or band behind it (such as white on white after a light restyle) are drawn in a readable dark or light colour; readable colours are kept as you set them. Rebuild the application to pick this up.
- A chart's axis labels, axis names and legend now use the font colour set in the chart widget's style instead of a fixed grey, so they are readable on a dark chart panel. A chart with no font colour set looks as before.
- A donut chart PIES AI builds, or a chart you ask it to change to a donut, now shows with its hole in the editor and in the preview instead of as a full pie; changing it back to a pie fills the hole again. A donut chart saved before this update still shows as a pie until you ask PIES AI to change it to a donut again.
- Tables in the editor canvas show the font, background and header colours set in their widget style, as built applications already did; a colour that would be unreadable on its background is drawn in a readable dark or light colour instead.
- In a generated application with a dark theme, or on a dark section of a page, tables no longer appear as white boxes: they take dark surfaces, borders and header with light text, and the Columns button gets readable text and a visible border. Light sections look as before. Rebuild the application to pick this up.
- In a React application, a dropdown on a dark background shows its Select... placeholder, its chosen value and the text you type in a light, readable colour instead of the default grey or near-black; the placeholder is drawn slightly fainter than a chosen value. A light text colour you set yourself is kept, and dropdowns on light backgrounds look as before. Rebuild the application to pick this up.
- A dropdown's Default Value can be typed as the option you see, such as Company, as well as the option's stored value. In Live Preview and built React applications the matching option is pre-selected on Add screens (the match ignores upper and lower case), the record is saved with the option's stored value, and so the Update screen shows it too. Rebuild the preview to pick this up.
- In a React application, the Admin Console and its dialogs follow the app's theme: with a dark theme the console is dark and readable instead of white, and light themes look as before. Reopen Live Preview or rebuild the application to pick this up.
- Custom widgets: New Custom Widget starts on Screen Widget (API apps get Function (Go) only), starter code keeps your widget's name, and Library → Widgets explains what belongs there.
- Generated event handlers now tell their caller what happened: a handler returns its Call Function result as
{ ok, data, error } even without a Return Data step, and a failure returns { ok: false, error } instead of nothing. A custom widget that saves or deletes a row can check the result and show the error, rather than re-reading the table to find out.
- A custom widget given a percentage width, such as
100%, now fills that share of its screen in built applications instead of shrinking to a narrow strip, so a fixed pixel width is no longer needed. Parameter values set in the widget's code block now reach the widget when no screen-level values are set; screen-level values still take precedence. Rebuild the application to pick this up.
- A React custom widget whose height is set to fit its content, with a minimum height, now shows as a card of real height on the editor canvas, instead of a flat tile that left the screen's main area empty, so the canvas matches the running application.
- Library → Widgets opens on a System tab with the built-in and registry widgets, each with Customise; tabs are System, Designer and My published. Library → Templates shows the system templates with Use, and its sidebar count matches your own templates.
- Every transactional email (deployments, invitations, password resets) uses one branded layout with your logo and a plain-text part.
- The Data tab shows the page holding a record you just added and confirms the save. Installing a template prefills a free application name.
- Sign in with PIES Studio works from a preview opened in a new tab. In Hobby, it signs you in as your local account without asking for a password. Open Preview keeps waiting while a preview is still starting and says why if it gives up.
- On a self-hosted Enterprise installation, a preview now loads its tables and sample rows the first time it is built. Before, the preview database could start empty, so tables and charts showed no data and actions failed even though the build said the sample rows were added. Rebuild the preview to pick this up.
- Opening a preview that is not running now starts it. If a build ended without restarting the preview, or the preview's processes stopped, the preview address shows a starting page and the app opens by itself a few seconds later, instead of a preview error you could only clear by building again. See Error reference.
- A failed deployment shows the reason it failed, and a hint where there is one, in the editor's deploy console and on the deployment, instead of no reason was recorded. See Error reference.
- A shut-down deployment shows its services as Stopped, with Open turned off on the Frontend and Backend until you start it again, and scheduled starts and shutdowns appear in the deployment's Activity Log. A deployment schedule is checked every minute, so a short start or shutdown window is no longer missed; a scheduled action that fails, for example because the build engine is unreachable, is retried every 30 minutes, and the Activity Log names the action that failed.
- A Find Single Record step whose lookup value cannot be read now shows an Incorrect Configuration problem naming the step and quoting the value, instead of a vague function could not be generated message; wrapped forms such as
${id} or {{id}} are read as $id. See Error reference.
- Selecting a step that has no settings in an event or function, such as Navigate to Previous Screen, Close Popup, Parallel, End Parallel, Break, Finally or End Try, now shows a short note in the Properties panel explaining what the step does, instead of an empty panel.
- Downloading an application's code from Deploy & Publish no longer times out on a large or busy application. The code is generated in the background while the dialog shows Generating application code… with the time so far, and the zip downloads when it is ready. The zip now leaves out installed packages and build output (
node_modules, .next), so it is much smaller; the packaged Dockerfiles install them when you build.
- A screen or function name must be 3 to 255 characters long. File → New → Screen and Function now tell you so in their own words (Screen cannot be added…, Function cannot be added…), not with the old Layout cannot be added message or a generic Please provide a valid name.
- The File → New → Screen and Function dialogs have a × close button and also close when you click outside them or press Esc, without creating anything.
- Asking the AI to add a form to the screen you have open, for example add a new request form above the list, now adds just the form where you asked, instead of re-laying out the whole screen and putting the form below the list.
- A table can show a search box above its rows: tick Search box (above the table) in the table's properties. Typing in it hides the rows that do not contain the text in any column, in both React and Angular applications. The table's filter dropdowns now also show on the Studio canvas, and asking the AI for a search box or filters above a list turns the search box on for you.
- A table row action that raises an event now runs that event when the row's button is clicked; before, an action set to an event could do nothing. An AI assistant building through PIES Studio's tools can now add up to three row actions to a table, each opening a screen with the row or raising an event for it.
- When your request to the AI names a screen, for example a Customer List screen, the screen is now saved under exactly that name, not a near variant such as Customers List.
- Every screen the AI creates for a generated application, in a whole app or a follow-up request, is now added to the application's navigation menu (sign-in and sign-up pages excepted), instead of the menu listing only the landing screen.
- When the first screen of a whole app is a list, a table or a form, PIES AI builds the starter Home Page as that screen (for example an Orders List showing your orders) instead of a welcome page with getting-started steps and suggested areas. Dashboards and landing pages are built as before.
- A code block that opens a database transaction and never commits or rolls it back no longer makes every request to the application hang: the transaction is rolled back after 5 minutes (
PIES_TX_TIMEOUT changes this) and its connection is freed. Always end a transaction with Commit or Rollback. See Error reference.
- In an event's Simple action → Call Function, choosing the function now fills each of its parameters with the matching element on the screen, for example
$form_hospital for a hospital parameter, instead of leaving them blank. A parameter stays blank when no element, or more than one, matches; Save still refuses a $ reference to an element the screen does not have.
- Asking the AI to add a field and chart or show it, for example add a priority field to jobs and a chart by priority, now fills sample values into the new field on your existing rows, so the chart is not empty. Asking for only the field still leaves existing rows empty. See Quickstart.
- A Count Card has a Record mode (value vs capacity): instead of totalling a table, it shows one record's value against its capacity, filtered for example on
$routeParam.id, with the percentage, a bar coloured by threshold (green, amber from 80%, red from 95% by default) and a sub-line such as Spare {spare} {unit}. In its properties the record-mode switch comes first and hides the totalling settings, the card uses a single unit, and the filter offers route parameters and fields to pick from; on the Studio canvas each card shows sample figures with its own percentage. Threshold colours you set are now kept when the AI restyles the application. A record-mode card can also take its unit from a column with Unit field (next to Unit), so one screen shows A, kVA, kW or L depending on the record, and its sub-line can show any column of the record with {column}, for example Autonomy {autonomy} (design {design_autonomy_h} h). When several Count Cards share a narrow row, a long label wraps onto a second line instead of being cut short, and the value is always shown in full. See the user manual.
- In a function's flow, a code-block step is now labelled Code block with the block's name underneath, on the canvas card, in the step list and in the inspector, instead of Custom Widget with the language name. Saved functions are unchanged.
- When the AI builds or extends an application, a button that does only one thing (open a screen, go back, or call one function) now gets a Simple action on the button itself instead of a separate named event. The Explorer lists only events with more than one step, so a generated app no longer shows one event per button. Events your application already has keep their names.
- Asking the AI for a settings, preferences, profile or account page now builds a short header and a form with setting fields and a save button, instead of text sections that only describe the settings. If the AI fills that form with your table's record columns (for example Title, Status and Priority), PIES Studio turns them into real settings instead: a Default … choice for each of those columns, plus Email notifications and Notification frequency. The page's heading, fields and save button sit together in one card, lined up on the same left edge, including on a phone, instead of the heading and button sitting outside the form or the form showing as a second shadowed panel inside the card. On a wide screen the card is about 880 pixels wide with the fields in two columns, and a save button you have not labelled reads Save settings instead of Submit; other forms, such as a contact form, keep Submit.
- An event's Simple action can now use two more steps: Go back returns to the previous screen, and Save form saves a form on the screen that you pick. Save form runs the form's own Save, with the same checks, and saves the record once. Neither step is offered for a table's row actions.
- A widget can now be shown or hidden by a value of the record its screen is showing: in Behaviour → Conditions,
$record is the record a form on the screen loads — even a hidden one, so the view page need not show an edit form — so one item-view screen can show board and breaker sections only for the asset types they apply to. It works on buttons, tables and containers, and a hidden widget in a row or grid no longer leaves a gap. Tables have a new Hide when empty option under Appearance, so a section with no rows disappears instead of showing No data yet. See the user manual.
- The Decisions CSV export uses the table's columns and labels, and a submitted prompt in Ask PIES AI has a copy button.
- While an application opens in the editor, the canvas shows a centred card reading Opening <application name>… with a spinner and placeholder rows, in light and dark themes, instead of a small unlabelled spinner on a blank canvas.
- While a table's rows load, the database Data tab shows a spinner and Loading records… at the top, instead of only the Add Record form with no sign that rows are on their way. Switching between the Schema and Data tabs no longer slides, so the schema is never drawn under the data.
- On the database Schema tab, the header row (Column name, Data type, Primary key …) stays at the top while you scroll a long column list, the same way the Data grid does, so lower rows are never shown without their labels.
- In the Studio dark theme, the message shown when Admin → Disk Usage cannot load its figures is a dark red banner with red text, instead of a near-white strip.
- In the Studio dark theme, secondary buttons, dialogs, boards and the PIES AI chat (including its Copy buttons) now use dark-theme colours with readable text, instead of keeping light-theme colours. Icons in toolbars, chips and switches, such as the AI runs chip in the page header, sit centred on their labels at the same size in light and dark themes.
- The page title in the editor canvas header is now the label of the menu item that opens the screen (such as Home), the same title the running application shows, instead of the screen's own name (such as Home Page). A screen that no menu item opens still shows its screen name.
- On the editor canvas, selecting a small widget, such as a short button, an icon or a chip, no longer covers it with the Edit button. A small widget gets a pencil icon just above its top-right corner instead (Edit properties on hover), so you can still read what you selected; every other widget, including count cards, tables, containers and text, gets its Edit button just outside, above its top-right corner. When there is no room there, it goes below or beside the element, never over it or a neighbour. Double-clicking a widget still opens its properties.
- Steps in the event and function editors use the same selection: the Edit button sits outside the selected step and never covers it or the next step, even zoomed out. Double-clicking a step now opens its editor; on a Call Function or Call Event step it still opens the flow it calls.
- The editor now explains your application in plain sentences, with no extra panel or view. In the Explorer, each event under a screen reads as a sentence, such as Adds the breakers, and opens to the functions it calls and their steps, down to the last one. In the Inspector's Steps list each step reads as a sentence with its technical label underneath, running the full width of the row with no buttons beside it; clicking a step selects it on the canvas, where its settings open. A Call Function step opens in place to the called function's steps. In the Outline, a widget with behaviour shows does 3 things; opened, it reads When clicked, this element: and names every function reached, every table it adds to, changes or looks up, and the screen it opens, without a dialog. Every function tab has a single-line Used by, such as Used by the Save button on Add Breaker, and a long list opens grouped by screen. You still change behaviour in the event and function editors.
- In the Outline, a widget that runs an event, such as a Save Site button, shows the event's lightning bolt right after its name, before does 4 things. Every row above it (container, form and screen) shows a smaller muted bolt with a count, such as 1 inside, so a collapsed branch still tells you something inside it does work. Containers with no behaviour inside show nothing extra. Hover the bolt to read what it does, such as When clicked, this button: followed by its steps.
- Reading logic no longer fills the editor with tabs. Opening an event or function from the Explorer, the Outline or Used by reuses one preview tab, shown rightmost with an italic title; the next such open replaces it. Editing it or double-clicking its tab keeps it as a normal tab. A Back control at the start of the breadcrumb returns to where you came from, and the breadcrumb shows the screen, widget and event you drilled from. The tab menu has Close saved beside Close others, and at most 8 normal tabs stay open: opening another closes the oldest one with no unsaved changes.
- A button whose logic you set as a Simple action in Automate reads as one plain sentence in the Outline, such as Saves the record to Breakers, then opens Board Breakers, with set in Automate · Change on the right. Change selects the widget and opens its Simple action, where you change it. In a function's Used by such a button reads Used by the Save button on Home Page. Events and functions you created keep their links.
- PIES AI explains and changes a selected element from the same sentences you read in the Outline. Select a widget, such as the Save button on Add Breaker, and ask what does this button do: the answer is the Outline's sentences word for word, such as When clicked, this button: and Shows the message “Created.”, each with its technical name on the right, and nothing made up. Ask to change what it does, such as change what Save does: show the message “Breaker saved.”, and PIES AI changes that step of that button's event in place; the rest of the screen and the app stay as they were.
- Function tabs are tidier. Opening a function no longer opens the build console; it opens only when you build. The flow fits the canvas when the tab opens and the status bar shows its real zoom. The Steps list has one row for every step on the canvas, in the same order, and its count matches the canvas. Structural steps read as sentences: an If reads Only when a condition holds with its branch indented beneath it, an Else with steps reads Otherwise: with its steps beneath it, and an End If reads Otherwise, skip to here, muted. An empty Else is not a step on the canvas, so it has no row. Selecting a row selects its step on the canvas, and selecting a step on the canvas highlights its row. Used by chips show an icon for what calls the function: a function, a custom widget, another widget or a screen. In Function Details the Description is optional and its box starts at one line and grows as you type. When you hold the lock on an app, a Locked by you chip in the status bar replaces the row above the Inspector; it opens Release Lock and any requests waiting for the lock, which you can open or decline. When more tabs are open than fit, arrows appear at the ends of the tab strip and no tab is cut off part-way. In the Explorer, each function and event reads once: a function with a description reads as its first phrase, such as Remove a board power source, with its name muted on the right; one without reads as its name in words, such as List feeds, with nothing repeated beside it. In a narrow Explorer the muted name shortens first so the sentence keeps its words. The sidebar's Agents label stays whole beside its count.
- The Inspector's Steps list always shows the same steps as the canvas of the open function or event tab. Switching tabs quickly, saving and then switching, or letting PIES AI change several functions no longer leaves another function's steps under this one's name. When the open tab has changes you have not saved, the Steps list shows your draft, the same as the canvas, and its header says unsaved.
- You can now change a step straight from the Inspector's Steps list. Select a row and press F2 to change what its sentence names, such as the table a step adds to, the message it shows or the event a Call Event step runs, picking from suggestions that narrow as you type. Press Shift + F2 to change what the step does within its kind, such as Adds it to a table to Removes it from a table, keeping its table or message. In a condition, suggestions offer words such as is, is not and is more than, and then the values the column can take. Enter or Tab accepts, Esc closes, and the arrow keys move through the suggestions. A step can also be moved up or down within a run of plain steps; the start, the end and branches stay where they are. Changes become part of the open tab's draft and are kept when you save, the same as edits on the canvas. From the Explorer and the Outline, select a step and edit it in the Steps list. The event and function editors remain the full editors.
- A function tab can now be written as a script. Use the Canvas / Script switch above the flow; the tab remembers your choice. Script is a text editor: type anywhere, one step per line, as the step name followed by its settings in brackets, in the order the step's properties show them, for example
Create Record(assets, $record, result) or Return Data($results). You can also name a setting, as in Create Record(table: assets, record: $record, result: result). Conditions and loops are blocks indented by four spaces: IF ($record.site != "") … ELSE … End If, and LOOP, WHILE (condition) or FOR EACH ($item IN $list) … End Loop; typing the opening line adds its closing line for you. Text is double-quoted, # starts a comment, and step names and keywords can be typed in any case. Suggestions open as you type: step names at the start of a line, then your tables, screens, functions, events and elements, $ values, a table's columns after a dot, operators and true / false / null; after ( and each comma a hint shows which setting comes next, and hovering a step explains what it does in plain words. A line that does not read is marked and changes nothing until you fix it; an unknown table or a missing setting gets a muted note and never stops you typing. The canvas shows the same words: each node is titled with the step name and its settings underneath, such as Create Record over (assets, $record, result). Functions using Switch, Try or Parallel blocks open read-only in Script; edit those on the canvas. From 1.9.63 this switch reads Canvas | Code and sits at the left of the tab's toolbar; see In 1.9.63 below.
- Event tabs have the same Canvas / Script switch. In Script, an event reads one line per step, and the step picker offers the event steps, such as Navigate to Screen, Show Message and Set Element Data. Double-click a step to insert it after the selected line with its first box open, such as the message to show; press Enter to commit, and the line reads as a sentence, such as Shows the message “Order saved”. Backspace on an empty line removes it. Changes become part of the tab's draft until you save, the same as edits on the canvas, and switching back to Canvas shows them there. From 1.9.63 Script is called Code.
- The Inspector's Steps list now reads the same as Script: each row is the step's script line, such as
IF ($record.site != ""), Create Record(assets, $record, result), Return Data($result) or End If, indented as in the script and coloured the same way, with no second line underneath. The plain-English sentence for a step, such as Returns the data, shows when you hover its row. The start and end rows are unchanged. In the step picker beside Script and in the toolbar's step menus, each step is listed by its name, such as Create Record, Set Variable or For Each, and hovering it explains what it does in plain words.
- A function's Used by strip now stays on one line however many places call it. It shows the count, the first few callers as chips and +N more; the same event on many screens collapses into one chip, such as On load · 25 screens. +N more or that chip opens a list grouped by screen, with a count per group and a search box, and each row opens that screen. Long names are shortened, with the full name on hover.
- Where used is new on functions, tables, columns and custom widgets, in the Explorer's menu and in search results. A function opens with its Used by list expanded, grouped by screen; a table lists the functions that read it, the functions that change it and the elements that show it, in plain sentences, such as Create breaker adds records to breakers. Renaming a function lists its callers before you confirm, then updates every one in one save. Deleting a function, column or custom widget that something still uses is blocked: the dialog lists every place that uses it with links, says Delete is blocked until these are changed, and offers Open Where used.
- Corners in an application now follow two sizes from its theme: 8 pixels for controls such as buttons and fields, and 12 pixels for panels, cards, tiles and table frames. Corner Radius on a widget's Look tab is a choice of Square, Control (8px), Panel (12px) or Round instead of a free number, and corners PIES AI sets when it builds or restyles a screen are rounded to the nearest of the two sizes (square corners and round, pill-shaped ones are kept). Count cards use the panel size. Existing applications keep the corners they already have until a widget's corners are changed or the screen is rebuilt. A container with no corner radius set is drawn square in the running application, just as the editor canvas shows it; other widgets with no radius set keep the 8-pixel control size.
- Opening a screen in the editor is faster. A screen you have already opened comes back at once, with no loading screen. The first time you open one, the canvas shows a light outline of the screen in your app's own colours (header, menu and content) where the real screen will appear, with one line naming the step under way, such as Loading screen definition or Loading menu and header. If a step takes more than 5 seconds, the line says … is taking longer than 5 s and offers Retry. The Inspector's function list fills in on its own without holding up the canvas.
In 1.9.63
PiLang: functions, events and screens as code
- Functions and events can be written as code. Every function and event tab has a Canvas | Code switch. In Code each step is one line of PiLang, such as
Create Record(assets, $record, result), with IF … ELSE … End If and LOOP / WHILE / FOR EACH … End Loop blocks indented by four spaces, # comments and double-quoted text. The canvas and Code are one draft: change either and the other shows it. Switch, Try and Parallel blocks are still edited on the canvas.
- Steps insert with placeholders. Picking a step in Code, from the Steps palette or the suggestions, inserts it with a named placeholder per argument, such as
Set Variable(name, value); Tab moves between them, each offers the suggestions that fit, and blocks come with their End line. Placeholders are never saved, and a required one left empty is flagged when you leave the line. See PiLang.
- Screens have a Code view too. A screen tab's Design | Code switch shows the screen as text that reads like its layout: a
Screen header with its size and the event it runs when it opens, then Row, Column, Panel and Form blocks with their End lines and elements indented inside. Only settings you changed are shown, data reads as expressions such as Count Card "Load" = Sum(assets.kva) or Table … from boards, events as -> EventName, theme colours by name, and long HTML or text folded to one line. Changes go back to the designer. See PiLang.
- One switch on every tab. The view switch sits in the same place on every tab, in the tab's own toolbar at the left, with the same look and words — Design | Code on screens, Canvas | Code on functions and events — and the tab remembers your choice. The selected view is the filled segment, and Ctrl+Alt+V (⌥⌘V on a Mac) flips between the two. See The editor: Code and Canvas.
- Suggestions that fit. In Code, suggestions offer what fits where you are typing: step names at the start of a line, your functions for a function argument, your tables for a table, a table's columns after a dot, and a fresh name for a result. Suggestions, hints and hover explanations match the Studio's look in light and dark themes, with an icon for each kind.
- Every word coloured. Step names, keywords, text,
$ values, operators and comments each have their own colour, readable in both themes.
- Selected code stays readable. In every Code view, selected text is shaded with a light tint of the theme's accent colour instead of a solid block, so the words keep their colours. The current line, other matches of the selection and search matches each have their own softer shade, in both themes.
- A dark designer in the dark theme. In the dark theme the screen designer's area around the page is now dark instead of white, matching the Canvas and Code views; the page keeps your application's own colours and gets a thin border. The light theme is unchanged.
- The canvas, the Steps list and the Steps palette speak the same code. A canvas node is titled with the step name and its arguments beneath, a Steps list row is the step's code line, and the Steps palette lists steps by name. The plain-English sentence for a step still shows on hover, in the Outline and when PIES AI explains something.
Build with AI
- Every screen a whole-app build makes is designed and judged. List, form and detail screens, the home page and the menu go through the same design pass and design judge as a screen you ask for in the chat, so a built application looks like one you designed screen by screen. When an application's own policy sends its builds to a cloud model, the build runs up to four units at once. See Build with AI.
- Asked-for filters and Add buttons are built. A screen whose description asks for a filter gets a filter bar, and an Add button opens a form for adding the record, built if it was missing, including on a private model.
- Edits show on the open screen straight away. When PIES AI changes the screen you have open in the editor, the canvas shows the changed screen as soon as it is saved, instead of the old screen until you reopened the application.
- Charts on the built-in user and role tables plot their data. A chart PIES AI builds on the user or role table, such as Roles by name, now shows its bars instead of a single empty Unknown bar.
- A failed Diagnose says why. When Diagnose in a running preview cannot finish, for example because no AI model is answering, the panel now shows the reason instead of (no verdict text), or The debug agent returned no verdict. Try again, or rephrase the request. when there is none. See How AI works.
- Even spacing under dropdowns. In a React application's add and edit forms, a dropdown no longer leaves an empty band below it for an error message it cannot show. The next field now sits the same distance below a dropdown as below any other field; a dropdown with validation rules still keeps room for its message. Rebuild the application to pick this up.
Coding agents
- Build with Claude Code, Codex or Cursor. Hobby can be driven by your own coding agent. Install the
pies plugin in Claude Code (/plugin marketplace add pies-io/claude-plugins, then /plugin install pies). Then /pies-build builds an application with tables, sample rows, screens, a dashboard and the menu, /pies-run opens it in your browser and in the editor, and /pies-explain describes it. Codex CLI and Cursor connect with a one-line setting. On Hobby, a new Connect your coding agent card in AI Settings shows the line to connect with, for the port in use, with a Copy button. Whole-app builds run on your agent's own model. See Build with Claude, OpenAI or Cursor.
- Your agent learns the PIES format before it builds. The Studio MCP server now publishes a compact spec sheet,
pies://spec, with the exact shapes of a brief, table, screen, function and dashboard and the rules Studio checks. It is generated from Studio's own checks, so it always matches them. A build-app prompt gives agents the recommended sequence and a worked example, pies://app/<id>/summary describes an existing application in a few lines, and a brief with mistakes is now refused whole, with every problem listed at once and nothing half-built. /pies-build now reads the spec sheet first and builds from one complete brief, and PIES AI's own builds take their reserved column names and checked rules from the same sheet. See Build with Claude Code, Codex or Cursor.
- Agents build a whole app in three or four turns.
build_from_brief now carries the full shape of a brief in its own description, accepts the common ways agents write a dashboard or sample-row counts, turns a figure counted by status into one figure per status, and replies with everything that was built, so the agent neither reads the spec sheet first nor reads the app back afterwards. In our own measurement, one run per model, Claude Opus, Sonnet and Haiku each built the job-tracker brief in 3 to 4 turns at 9% to 24% of the cost of the same model building the app on its own. See Build with Claude Code, Codex or Cursor.
- Agent builds look designed. A coding agent's brief can now set the app's theme and each screen's layout (a header, key figures, charts, cards, detail panels, empty-list text, icons), and every screen, not only the dashboard, is built through the same designed path PIES AI uses. Without design instructions the app still gets one theme, related records shown by name, no row-number column and a compact header on list and form screens. The new
review_screens tool shows the agent a small screenshot of each screen with a design score and notes, so it can fix and check again; at most two rounds are recommended. In our measurement the agent's build through PIES scored level with Claude writing the app itself, for 48% of the cost. See Build with Claude Code, Codex or Cursor and the measured comparison.
- A measured comparison of agent builds. Your agent plans, PIES writes the code reports one brief built twice with the same model, once by the agent writing React, Go and MySQL itself and once through the Studio MCP server: 41% of the output tokens, 72% of the cost, 43% of the time, with the gaps in our own result shown.
Editor
- Menu and dialog labels are in sentence case. The editor's File, Edit, View and Help menus, the tab menu, the palette groups and the Duplicate app dialog now read like the rest of the Studio, for example Save all, Duplicate app, Close window, Keyboard shortcuts, Close others, Visual elements and Select all. The commands themselves are unchanged.
- Zoom in the Menu & Header designer. Navigation → Menu & Header now has a zoom control at its top right, like the screen designer: −, the current percentage, + and Fit. It opens fitted to the width of the pane, so the whole header, including the widgets on its right, shows without scrolling sideways, and it refits when you resize the editor. − and + step by 10%, from 25% to 200%; Fit goes back to the fitted size.
Documentation
In 1.9.64
Studio
- One Library page. The sidebar now has a single Library entry instead of separate Templates, Widgets and Themes entries. It opens one page with Templates, Widgets and Themes tabs, each with its count, and Review & Manage at the right for administrators; switching tabs does not reload the page, and older links still open the right tab. Templates are now cards, your own first and then the built-in ones, each with its industry, description, how often it has been used and a Use button that starts a new application from it. Search and the All, Built-in, Yours and In review filters narrow the cards, and Hide test items, on by default, keeps templates named as tests out of the way and says how many it hides. The Library badge in the sidebar now appears only while a review update waits for you. Widgets is described in the next item. See Templates and published assets.
- The Widgets tab matches Templates. Library → Widgets no longer has its own second row of tabs or a long list. It opens on a grid of widget cards: Your widgets (the ones you published, with their status and Manage) first, then System and community. Each card shows whether it is a screen widget or a function, its name, a PIES or Community label, its technology (React or Go), a one-line description, up to three tags, a favourite star and Customise. One row at the top holds the search box (Search by what the widget does), the kind and category lists, the All, PIES registry, Community and Favourites filters and the number of widgets shown; New widget opens the widget designer. The grid shows 24 cards at a time, with Show more for the next ones, so it opens quickly even with hundreds of widgets. Customise, favourites, publishing and review work as before, and older links to the designer or to your published widgets still open the right view.
- A new Home page. Studio now opens on Home, the first item in the sidebar above Applications. It shows what needs you (approvals waiting, failing agents, decisions, failed deployments, each with its action), the applications you worked on last, your live applications with their environment, version and health, and this week's AI spend, share on your own hardware and agent runs. Pick a workspace at the top, or (administrators) the whole organisation. New app, Import and Ask PIES AI are at the top right. Applications still lists every application. See Quickstart.
- Home shows what needs you, and is easier to scan. The Needs you tile now counts agents whose last run failed in the last day and blocked decisions as well as approvals, and names them under the number, such as Overload Sentinel failed · 1 decision blocked; the line under the greeting says 2 things need you. Needs you appears once, as the first of four tiles. Recent applications are compact cards, three per row, each with Open editor and Preview (draft) or Open app (live); New app is the button at the top right. Agents and Deployments sit side by side with problems first and an action on each row: See why, Run again or Check. See Quick start.
- The Decisions tile on Home opens the decisions log. Clicking Decisions this week on Home, or the Decisions card in a workspace, now opens the Decisions page with its log. Before, it showed a blank page. Older links to the Decisions page open it too.
- A clearer applications list. Each row now shows the application's icon, its status in words, edited by <name> with the time, and labelled counts of screens, functions, events and agents; health and privacy are written out instead of shown as unlabelled dots. Test workspaces are hidden by default (Show test workspaces brings them back), the header counts only what the filters show, Recently Deleted moved to the toolbar, and the list opens quickly even with thousands of applications. See the user manual.
- Every page has the same layout. All Studio pages, including Applications, Agents, Teams, SSO, Integrations, Admin and every PIES AI tab, now use the full width of the window with the same side padding and the same page title style, instead of some stopping at a fixed width or centring a narrow column. Home keeps its larger greeting. The browser tab names the page you are on, such as PIES AI Overview | PIES Studio.
- Image widgets set to File show their picture on the canvas. An image widget whose picture is stored as a file in the application now shows that picture on the editor canvas, as the running application does, instead of the dashed Upload image placeholder. An image widget with no picture yet still shows the placeholder.
- Grouped tables show their groups on the canvas. A table that groups its rows by a column, such as equipment by type, now shows the same group headings with their counts on the editor canvas, in the same order as the running application. Before, the canvas showed one flat list of rows.
- Table data pages stay in step. In Databases, opening another table's Data view now always starts on page 1 with that page's rows, and Next shows the rows the range label names. Before, after paging one table and switching tables, the label could restart at 1 – 5 while the grid still showed later rows.
- You can see keyboard focus in the editor toolbar. When you move through the editor's top bar with the keyboard, the search box (Search screens, events, functions), Run, the breadcrumb and zoom buttons and the Design / Code switch now show a clear ring around the control in focus, in light and dark themes. Before, the ring was too faint to see, and in the dark theme the Design / Code switch had none you could see. The selected Design or Code button now also changes when you hover it.
- Delete confirmations in the explorer are clearer. Choosing Delete from an item's ⋮ menu in the explorer now closes the menu before the confirmation opens, so it no longer stays open behind the dialog. The Cancel text is easier to read, and pressing Esc closes the dialog and puts keyboard focus back in the explorer.
- Editor toolbar buttons line up. In the editor's top bar, the Pick task chip is now the same height as Automate, AI runs and Run beside it. In the canvas tab toolbar, the download and open-in-new-tab buttons now match the height of the category buttons next to them, in Inspector, Databases and Automate. The AI runs chip in the editor header and on the Applications page is now a quiet outlined pill in your theme's accent colour, the same height as the buttons beside it, with no gradient, glow or pulsing; its icon still spins while a run is live.
- The Add table form lines up. In Databases, the name boxes and the type and reference dropdowns in the form's column list are now the same height as the Name and Description boxes and the Add Column button above them, so every control in the form has one height, in light and dark themes. Each Column Type dropdown in the column list now shows a single arrow, instead of the browser's own arrow drawn next to the Studio one.
- Notifications are easier to read. Information notices, such as Preview is rebuilding, now sit on a darker blue so their white text is easy to read, and the status and close icons in every notice are larger, in light and dark themes.
- A clearer Background Color field. In the Inspector, a screen's Background Color is now a small colour swatch beside a hex box, with a clear (×) button, at the same height as the other fields. When no colour is set the swatch is struck through and the box reads None, instead of a full-width black bar that looked like a black background. Clearing the field removes the colour, so nothing is saved as black.
- Signing in to an application no longer looks like a restart. After signing in to a built application or preview through single sign-on, the application shows a centred Signing in… message and goes straight to its first screen, instead of the Starting application page with its progress list. Studio's own Signing you in… page for an application is centred too. A running preview also stays open when Studio itself restarts. Rebuild the preview to pick this up.
- Exported code signs in when run with Docker Compose. An application downloaded with Export code and started with
docker compose up now signs in and shows its Home page. Before, its sign-in could not reach the application's back end and the page stayed blank. Export the code again to pick this up. See Hobby.
- A deployment's live log stays clean. While a deployment page was open, its live log showed a red no route error every few seconds, so a healthy application looked broken. The page's health check now asks the application's own health address, and those errors no longer appear.
- Azure deployments only offer VM sizes you can deploy. An Azure environment's VM size list now leaves out sizes your subscription has no vCPU quota left for in that region, and says so if none are left. If a deployment still fails on quota, the hint names the VM family, the region and what is left, and suggests another size, another region or a quota increase. See Errors.
- Cloud deployments on HTTPS sign in on HTTPS. After a cloud deployment is switched to HTTPS, signing in to the application now returns to the
https address instead of the old http one, and the old http address forwards to the https address. The is live email waits until automatic HTTPS has finished and links to the https address (or to the http address with a note if HTTPS could not be set up). An application built before this shows action needed: Publish changes after the switch; publish it to pick this up. See Platform installation.
- Invitation emails and the set-password page match your application. When you invite someone to a built application, the email now carries the application's logo, name and theme colours, with a Set your password button, the plain link under it and a line saying the link expires in 7 days (a password-reset link expires in 2 hours). Resending an invitation uses the same link to the same page, and a resend whose email cannot be sent says so, with the reason. The link opens a set-password page styled like the application's sign-in screen, with labelled fields, the password rules and an error only when there is one, and it loads nothing from the internet, so it works on an air-gapped installation. The password-reset email looks the same. An application with no theme uses the Studio default theme. Rebuild and redeploy an existing application to get it.
- API docs open on a deployed application. Opening
/openapi.json or /docs on a deployed application now takes you to its Swagger spec on the same address. Before, the browser was sent to 0.0.0.0:3000 and could not connect. Redeploy an application to pick this up.
Agents
- Agents opens on an overview. Agents now opens on one overview: workspace chips, one row of counters (Needs you, Failing, Running now, Idle), the Agent map with one tile per app, problems first, and the runs that went wrong in the last day. The Table and Map toggle and the second grid of agent cards are gone. Click an app tile to see that app's agents, with a breadcrumb back to the overview; click a counter for the agents in that state, or All agents for the full list. Each row now shows how its last run ended. An agent counts as failing from a failed run until its next good run, and the overview, the list and Home's Agents tile now show the same numbers, all following Hide test fixtures. See Agents.
- The agent list groups by app. The All agents list now groups agents by app, one collapsed line per group with its agent count, failing count and 30-day cost; expand a group to see its agents. Group by status, owner or model, or choose None for the flat list. See Agents.
- The Private AI offline warning is accurate. Posting an agent while PIES Private AI is offline now warns only when the app's AI policy sends agent runs to PIES Private AI; an app that uses a cloud model is no longer warned. The N agents waiting line now counts only agents held by the current outage, not agents that failed in earlier ones. See Agents.
- Map tiles that need you are easier to read. On the app tiles of the Agents overview in the light theme, the amber status line on a tile that needs attention, such as 1 agent waits on you · 2 agents failing, is now a darker amber that stands out clearly from the tile.
Build with AI
- AI-written custom widgets fill their space. A custom widget now fills the area its screen reserves for it, even when it shows only an empty message, so no blank gap is left above the buttons below it. Rebuild the application to pick this up. See Build with AI.
- Menu badges are always readable. A menu item's badge given a theme colour, such as info, now shows as a filled pill; before, its white text could sit on the white menu with no fill. Rebuild the application to pick this up. See Build with AI.
- Plain labels on buttons and menus. Home-page card buttons, back buttons and menu items now read Open Contacts, Add contact, Back to Home or New contact, instead of repeating screen names such as Open Home Page or Contact Create/Edit. Rebuild the application to pick this up. See Build with AI.
- Every list screen has an Add button. A table's list screen now has a filled Add Company, Add Contact (and so on) button in its header that opens the table's form, so the main action on the screen is always in sight. Rebuild the application to pick this up. See Build with AI.
- Readable category values in tables and pie charts. A table cell, badge, pie legend or chart tooltip showing a stored value such as customer_success or north_america now reads Customer Success or North America. Identifiers, email addresses and free text are shown as stored. Rebuild the application to pick this up. See Build with AI.
- Yes/no and money columns read properly in tables. A list screen's table now shows a yes/no column as Yes or No instead of 1 and 0, and a money column, such as cost (AUD) or price, as an amount with its currency symbol and two decimals, such as A$1,250.50, instead of a bare number like 1250.5. This holds in the editor and in the generated application; a display type you set on a column yourself is kept. Rebuild the application to pick this up. See Build with AI.
- Number columns line up on the right. In a generated application's tables, a column of numbers, amounts or percentages is now aligned to the right, heading and cells alike, so figures are easier to compare; before, it lined up on the left like text. A column you set to a specific alignment keeps it. Rebuild the application to pick this up.
- Menu icons match their items. Each menu item of a built application now gets an icon that fits its name, such as Contacts, Companies, Tasks or Imports, instead of the same list icon on every item. Rebuild the application to pick this up. See Build with AI.
- Detail screens line up. On a detail screen built with AI, the header card, the field card, the tables and the activity timeline now share one left edge and width, instead of the first cards sitting wider than the tables below them. Rebuild the application to pick this up. See Build with AI.
- Pie charts in narrow cards stay inside them. A pie or donut chart with its legend at the side, in a card narrower than about 560 pixels, now names its slices in the legend only, instead of drawing labels around the pie that ran past the card edge or under the legend. A thin donut ring keeps its percentages in the legend and tooltip instead of squeezing them into the ring, a side legend starts below the chart's title, and in a narrow card the donut moves clear of the legend. Rebuild the application to pick this up. See Build with AI.
- Filters on yes/no columns are kept. A screen asked for only sites where critical = true now filters on the table's critical_site column instead of showing every row. See Build with AI.
- Figma import lists frames quickly and explains errors. A link to a whole page of a large Figma file now lists its frames in a few seconds instead of staying on Reading file…. A Figma error shows a clear message in the dialog; when Figma has paused access for your account, the message names the time the pause ends instead of saying try again in a minute. See Build with AI.
- Split-panel screens no longer fail the build. A split panel (a list beside a summary chart) on a table that links to another one, such as contacts that belong to a company, used to give a preview build error about the chart's column. The summary chart now groups by the table's own status or category column, and when the table has none the screen keeps the list without the chart. See Build with AI.
- Text just below a coloured band keeps its colour. On a new application's starter home page, the GET STARTED heading that sits directly under the coloured banner keeps its dark text on the white page; before, the readability check treated it as sitting on the banner and turned it white, so it could not be seen. See Build with AI.
- Default widget cards match. Charts, count cards, tables, forms and lists placed with their default look now share one soft card shadow, instead of charts using a heavier shadow and count cards a lighter one, and a form card gets the same 16-pixel inner padding as a table card. A shadow or padding you set yourself is kept. Rebuild the application to pick this up.
- Buttons whose function fails say so. When a button's event calls a function, keeps its result and the call fails, the application now shows This could not be saved: … and stops the event, unless a later If step checks that result. Before, the event carried on and the button seemed to do nothing. A Navigate to Screen step aimed at the screen already open now reloads it, so its tables show the new results. Rebuild the preview to pick this up. See Build with AI.
- Times saved from text are kept. A function that sets a date-and-time column from a text value, such as a variable holding the current time, now saves that time. Before, the new record got an empty time, or an update left the old time in place, while the function still reported success. Dates written as
15-11-2026 01:35:27, 2026-11-15 01:35:27 or in ISO 8601 form are all read; a value that is not a date at all is reported in the application log instead of being dropped without a word. Rebuild the preview to pick this up.
- New-record forms open cleanly. A freshly built application's form for a new record, such as New contact, no longer opens under This could not be saved. Edit forms and detail screens now load only their own record when they open, and finding no record leaves the form empty. Rebuild the application to pick this up. See Build with AI.
- Date pickers fit a phone screen. In a React application's add and edit forms, a date field's calendar on a narrow phone screen now shows the month and year in full, such as Nov and 2026, and keeps the whole month inside the calendar box, instead of cutting them short (202…) and letting the last week spill over the Save button. Rebuild the application to pick this up. See Build with AI.
- Date pickers use your theme colour. In a React application, the day you pick in a date field's calendar, and the day you move to with the keyboard, are now marked in your application's primary theme colour instead of a fixed blue. Rebuild the application to pick this up. See Build with AI.
- Form labels read on light form cards in dark themes. In a generated application with a dark theme, the field labels and placeholders on a white form card used the theme's pale text colour and could hardly be seen. They now follow the card behind them: dark text on a light card, light text on a dark card. Rebuild the application to pick this up. See Build with AI.
- Table rows read on dark sections. In a generated application, a table on a dark section of a page could show its rows and its CSV and XLSX export buttons in near-black text on the dark table, so they could hardly be read. The rows and both buttons now use light text there. Light tables and tables with a background colour you set look as before. Rebuild the application to pick this up. See Build with AI.
- Changing a screen's background colour keeps the screen. Asking PIES AI in the chat to change the background colour of the screen you have open now changes just that background and leaves every widget on it as it was; before, the request could rebuild the whole screen or change nothing.
- Adding a chart to a screen that has one works. Asking PIES AI in the chat to add a chart, such as add a pie chart of tasks by status, on a screen that already has a chart now adds the new chart and leaves the existing one as it was. Before, some models tried to change the existing chart instead, and the screen could stay unchanged. See Build with AI.
- Colour coding an existing list works. Asking PIES AI in the chat to colour code a list you already have by one of its columns, such as colour code the requests by priority, now shows that column's values as coloured badges (for example red for high, amber for medium and green for low). Before, the list could stay unchanged while PIES AI said it had done it.
- AI-built form cards end at their fields. When PIES AI builds or changes a screen, a form card that was saved much taller than its fields, such as a settings form, is now trimmed to end just below its last row of fields, so no large empty band is left under it. Background bands drawn behind other widgets keep their height. Screens built before this keep their size until PIES AI changes them.
- PIES Debug stays on previews. The PIES Debug button, with its traces and Diagnose, now stays on an application preview after it is built. Before, it disappeared shortly after a build, once the preview switched to its finished build. Deployed applications are unchanged. See Build with AI.
AI governance
- Small jobs can run on your own hardware. Turn on Owned hardware first on the Governance Overview (off by default, administrators only) and small well-defined jobs (one screen-spec or function step, one widget property, a chat answer) go to PIES Private AI whenever a private model is loaded. Large jobs still go to the stronger cloud model, and when Private AI is not running small jobs stay on the cloud model. An application's policy can turn it on or off for that application. The audit log records each call's route and the reason, naming the setting. See Governance policies.
- A clearer PIES AI Overview. The compliance posture score now loses points for failed Knowledge Base files and a high denial rate, and its hover explains what it measures; call counts read 10,000+ instead of stopping at 1,000; every provider has a colour in the legend; repeated denials are grouped with a count; model names are shown in full; and test policies are hidden from the Governance card. See Governance policies.
- Hide AI provider and model names for recordings. Turn on Hide AI provider and model names under the chat's gear icon → Preferences (off by default, kept in this browser) and PIES Studio shows Cloud AI or Private AI instead of vendor and model names: on chat replies, chat and version history, an agent run's audit trail, the Agents offline banners, and the PIES AI Overview and Audit. Vendor and model words inside policy names read Cloud AI too. The AI settings pages keep the real names, and only what you see changes: routing and the audit log are not affected. See Build with AI.
About this documentation
About this documentation
The documentation is now versioned with the product: use the switcher in the top bar to read the pages for 1.7, 1.8 or 1.9, and every page states the release it describes.