☀️ Fibery Product Report: July 2026

[mdubakov]

Here is the July product report with some delay, but better late than never.

July was quite productive month with relatively good focus. Initiatives assessment.

Granular Access. Not much
Growth. OK progress
Fibery Apps. Very good progress, Apps are release-ready now
Make AI Agents happy. Kinda OK progress, but not so many things released yet. In August should be more
Other. In general OK, many small things here and there, but it is expected

Granular Access

Under the hood

We’ve started Allow to hide Space data from Admins. Won’t see anything delivered to customers until we close all the vulnerabilities that’d open if we allow to hide things from Admins. Closing them one by one now with Dima leading the charge.

We don’t expect any major release until September — especially given Andrew’s 2-week vacation in August.

Adoption

Users visibility adoption approaches Guests now:

That’s pretty much what we expected .

Growth

Done

We’ve added a bunch of small ways for us to earn money:

• Allow to spend extra automation runs
• Allow to spend extra integration syncs
• Allow to enable extra usage during trial

And improved bunch of annoying things for Admins:

• Allow to close limits banner
• Update limits sidebar banner in ~real-time
• Notify Admins when approaching and reaching AI limit

In progress

Now we are working on Add usage dashboard for metered services, starting with allowing customers to analyze their AI consumption:

We expect a release somewhere in August.

Fibery Apps

NOTE: This section is outdated, since Apps are already released

We’ve implemented all important features for the release and technically we are ready. Now we are waiting for marketing team to prepare the launch event.

• Allow to add custom packages to generated app
• Recreating sessions for custom Apps
• Agent should test created app (by opening it)
• Switch to another model in App Chat
• Upload Files in app builder
• Support Custom Apps in Space Template
• Use external Agent to develop Apps (via MCP)

Next

In the meantime, we are continuing some improvements and fixes, like Version history for Apps and allowing users selecting elements Visual edit → click element, describe changes:

Some other near future features in apps are:

• New Embed → Generate App inside rich text block
• Duplicate App action
• Increase App chances to survive schema changes (renames, etc)

Next steps would be to explore Custom AI build Entity View (not very hard) and Custom AI build View Types (view “kinds”) (very hard) and react on users feedback after the release.

Custom apps adoption overcame Whiteboards already and still growing fast:

Make AI Agents happy

Many things are in progress here, but some improvements that were released in July.

• MCP got slightly more power with AI should be able to add color rules to views and Create Report Views via MCP.
• In addition, history and undo for automations was released: Automations Activity History and Undo for Automation History.

Next

There are many features related to better history tracking to understand who did what and allow undo of huge change sets. Our final goal is to have changes history for everything inside Fibery.

• Track additional info about how the change was made (MCP, API, etc)
• Show Details for changes in automations rules history
• Views history (activity log for Views)
• Batch undo/undelete after mass accidental changes

We’re also working on better rich text handling, it should make interaction via MCP more pleasant.

• Fibery AI and MCP: Update small part of rich text and add comments
• Implement permissions in document (collab) service
• Suggestion mode for documents

Third, we are expanding what AI can do with Fibery, bringing back automations creation and whiteboard handling:

• Create an automation (Rule or Button) with AI (attempt #2)
• Create an automation rule or button via MCP
• Access data from whiteboard in MCP and Fibery AI
• Create & Update Whiteboard View with AI

Finally, we decided to re-write Fibery AI Agent. Our current multi-agent approach has several drawbacks, so we are moving it into a single agent with set of tools Migrate Fibery AI agent AGAIN (to JITT).

Other

Some notable improvements are related to fields conversion. Also there are many small UI and usability improvements in many places. Our designers write more and more code every week!

Done

Performance

• Handle Large Datasets in Tables and Lists

Small assorted improvements

• Normalize palettes for light and dark themes on Whiteboard
• Filter notifications by date in Inbox
• Add an “Attach Files” action to the comment toolbar
• Instantly undelete (aka restore) an Entity (or other action where Undo toast is shown) via Ctrl+Z (Cmd+Z)
• Move Activity and Trash to bottom left menu
• Quick Search in Entity Activity log
• Sync several Jira accounts into the same database

Form View

• Restyle Forms
• Allow user to create new entities in relations

Whiteboard

• Upload and preview video files on Whiteboard
• Whiteboard: Template categories + 15 new templates
• Whiteboard: Workspace-level custom templates

Domain

• Convert Field: decimal → integer

Next

• Convert Field: single-select → multi-select
• Convert Field: select → Database
• Customize load limit (aka page size) for Relation View (Table, List)
• ? Pinned Filter: Filters inside Pinned Filters (and sort)
• ? Filters: When lower level is filtered, higher levels must be filtered correspondingly by default (hide empty lanes)
• Set workspace time zone for user-independent services

P.S. What was your favorite feature in July?
P.P.S. We have 1000+ paid accounts now. Here is the chart (Custom App, in fact, that we created in our Fibery CRM space) that shows weekly new purchases density:

[RonMakesSystems]

@mdubakov

Allow to hide Space data from Admins

Looking forward to seeing what this unlocks!

@mdubakov

Now we are working on Add usage dashboard for metered services, starting with allowing customers to analyze their AI consumption:

Can we also get usage per automation? So we can more easily optimize. I know its pretty simple to ask support for these numbers, but would be nice to be able to keep an eye on them real time.

@mdubakov

Custom AI build Entity View (not very hard)

This will be a pretty big deal on my end, entity view as a dashboard, let’s goooooooo!!! The biggest complaint I have not about custom apps is how detached they are from the rest of the UI ecosystem. Allowing this, as well as

@mdubakov

Custom AI build View Types (view “kinds”)

Would be some truly fantastic stuff.

@mdubakov

P.P.S. We have 1000+ paid accounts now. Here is the chart (Custom App, in fact, that we created in our Fibery CRM space) that shows weekly new purchases density:

Big win!! Congratulations to you all!

[mdubakov]

@RonMakesSystems

Can we also get usage per automation?

Sure, all such things will follow, including automations and integrations

[nathan_jay]

@mdubakov

• Use external Agent to develop Apps (via MCP)

Favourite feature

@mdubakov

Custom AI build Entity View (not very hard)

Favourite future feature! (try saying that 3 times fast).

@mdubakov

• Create Report Views via MCP.

This has been very handy to extend my existing reports. It would help if the formula fields were able to literal upload. I often need to create a custom formula field in an underlying database to display on a Report but the AI mangles the formula. So I end up doing a “cut and paste” to create the formula field. But the MCP access is helping a lot!

[bear]

Thanks for the update! I’ve bene wondering for a while: when will it be possible again to make and edit Custom Apps manually? (edit: I mean manually editing the code, so without AI)

[Sergey_Truhtanov]

We have this feature in our backlog, but it is not on the nearest horizon so far.

This may change if more similar feedback will come.

Below I’ll post a workaround, if you are very eager to do this. These are AI generated instructions (lol), but I’ve tested myself and it should work. We utilize same flow for Build Apps via MCP. There are basically 2 endpoints, to get App sources, and to upload archive with new sources to Fibery.

# Developing a Custom App by hand (no AI)

You can develop a Custom App entirely by hand: download its sources as an archive, edit them in your editor, and upload them back. The server builds the app in a sandbox and publishes the result — the same pipeline the AI agent
uses. All you need is a Fibery API token.

## Prerequisites

- A Custom App view already exists in your workspace (create it in the Fibery UI — every app is bound to a view; you can close the AI chat without prompting anything, the view is seeded with a working starter template).
- A Fibery API token (see [developers.fibery.com](https://developers.fibery.com) → Authentication). All calls below
  use the header `Authorization: Token <your-token>`.

Base URL: `https://YOUR_ACCOUNT.fibery.io/api/custom-apps`

## 1. Find your app id

```bash
curl -s "https://YOUR_ACCOUNT.fibery.io/api/custom-apps/" \
  -H "Authorization: Token $FIBERY_TOKEN"
```

Lists the apps you can see; pick the `id` of yours (match by `name` / `viewId`).

## 2. Download the sources

```bash
curl -s "https://YOUR_ACCOUNT.fibery.io/api/custom-apps/$APP_ID/get-source-files" \
  -H "Authorization: Token $FIBERY_TOKEN" -o sources.tar.gz
mkdir -p my-app && tar -xzf sources.tar.gz -C my-app
```

Everything lands under `my-app/files/` — the complete working tree: `package.json`, `pnpm-lock.yaml`, `index.html`,
`src/**`. The stack is Vite + React 18 + TypeScript + Tailwind v4.

## 3. Edit

Edit anything under `files/` except the platform-owned files — those are managed by the service and **silently
ignored on upload** (the server keeps its own copies).

- all versions: `vite.config.ts`, `tsconfig.json`, `platform.json`, `src/lib/fibery.ts`, `src/lib/cn.ts`

You own `package.json` and `pnpm-lock.yaml` — add dependencies freely; the server build runs
`pnpm install --no-frozen-lockfile`, so a hand-edited `package.json` without a perfect lockfile still installs.

You can run `pnpm install && pnpm exec vite build` (or `tsc --noEmit`) locally to catch errors before uploading.
Note that Fibery data access (`src/lib/fibery.ts`) is designed to run inside Fibery — verify actual behavior through
the app's view after uploading, not against a local dev server.

## 4. Upload

```bash
cd my-app && tar -czf ../sources.tar.gz files/ && cd ..
curl -s -X POST \
  "https://YOUR_ACCOUNT.fibery.io/api/custom-apps/$APP_ID/update-source-files?description=my%20change" \
  -H "Authorization: Token $FIBERY_TOKEN" \
  --data-binary @sources.tar.gz
```

The call runs the build synchronously and responds with JSON:

- `{"buildId": "...", "status": "success"}` — the app's view now serves your build.
- `{"buildId": "...", "status": "failed", "error": "..."}` — nothing published; `error` is the full, untruncated
  build output. Fix and re-upload. Note the HTTP status is `200` either way — check `status`, not the HTTP code.
- `409 {"message": "session_busy"}` — an AI turn is currently running on this app; retry after it finishes.

`?description=` is optional and labels the version in the app's version history.

[bear]

Thanks Sergey for your very useful feedback and to you (and the rest of the team) for realizing the ability to edit the code manually!

I have already made a Custom App today and it was useful to edit some things by hand. I will share this app when I’ve tested it for my own process, but basically it is a Google Docs like app, but integrated with Fibery. Every section (Chapter 3, 3.1, 3.2, and sometimes even paragraphs under a subchapter) has it’s own entity and title.

The H1 title of the Doc is hardcoded (for now), it’s nice that I can just edit it by editing the app.

Below the title it also adds a AI generated explanation of the app text, and I can just remove that by hand which is great.

Manual editing saves AI credits, it gives me an ability to tweak and above all it gives me a sense of control, which for me adds the cherry on the Custom Apps cake!

And to explain what that cherry means (to me): I’ve shared this before, but the principle of the Hierarchy of Needs from the book “Universal Principles of Design” explains that there is the “Creativity” level where Custom Apps (with AI and manual edit) fit very well. They enable us to make our own functionality beyond what (you) the Fibery team thought of and beyond what is possible out of the box. I really believe you guys are making a master move here with Fibery as a base (80%) + Custom apps (the 20%).

I had some more ideas today along this same line of thinking that I will share later!