Dan's Top 10 Appian Updates from 2025

We are back again with my favorite Appian updates from releases 25.1 through 25.4. After more than a decade working with Appian, I’ve learned that the features making the biggest headlines aren’t always the ones that make the biggest difference in our day-to-day work. So while my top 10 list excludes some of the flashiest new features, it showcases the updates that (in my personal opinion) are most exciting and practical as an Appian developer with the potential to make immediate, positive impacts on any Appian application.

Before we continue, let’s all please take a moment of silence for Quick Apps (2016 - 2025). RIP.

10: Title Bars (25.2)

The update:   Forms can now take advantage of a styled “title bar” instead of a plain text form label.

Why it made the list:  Minor UI improvements are some of my favorites. Each one might seem small on its own but they add up over time. If you look at UIs built four years ago in Appian vs. what you can do today it’s a night and day difference. These new title bars, and a few other styling options for forms, elevate Appian UIs keeping them looking sleek and modern.

9: Extra Long Text for synced records (25.1)

The update:  Synced records now support “extra long text” fields up to 64,000 characters.

Why it made the list:  This will be the first of a few features on my list related to Data Fabric. Two years ago I was very hesitant to use synced records and Data Fabric. Last year, I was more bought into the idea, but still felt like there were a lot of compelling reasons to situationally use CDTs and unsynced records. Now I am fully on team Data Fabric, and I cannot imagine going back. There are a lot of little reasons why Data Fabric has closed the gap, and the support for extra long text in 25.1 is one of many.

8: Smart Search (25.2)

The update: You can now query for synced records using an AI-powered semantic search, returning results with a “similarity score” for how well they matched the search term.

Why it made the list:  Smart Search is one I am tentatively excited about . The concept is great. Semantic search on your data fabric is extremely useful in a variety of situations - for business users searching a record list, or for matching extracted document text to reference data. However, there are row count limitations with text strings and documents that could impact higher volume applications. I will still use this situationally as it is but am looking forward to further updates in 2026.

7: Asynchronous Loading (25.3)

The update: Local variables can now be defined as an a!asyncVariable - allowing you to load the majority of your interface without needing to wait on slower loading items.

Why it made the list:  Appian has added async functionality over the last few releases to KPIs, charts, and grids which has been helpful, but limited. The new a!asyncVariable gives total flexibility for async loading. It’s important to use this sparingly and carefully, but it can be a powerful tool for improving user experience in the right circumstances. I will be using this on larger complex dashboards to asynchronously load slower and/or less important sections of the dashboard.

6: Select model for AI skill (25.4)

The update: Developers can now pick which Generative AI model that AI skill should use.

Why it made the list:  Generative AI skills did not make my top 10 last year, but continued improvement over 2025 with features like this one have helped shift my preference from using 3rd party AI providers to using Appian’s built-in private AI. The biggest benefit of this update is you can match up the most appropriate model to the task at hand. Simpler tasks requiring speed can utilize a model like Claude Haiku 4.5, whereas complex logic can leverage a reasoning model like Claude Sonnet 4.5. Prior to 25.4 it was unclear which underlying model a particular skill was using at all, so this added visibility and configurability is much appreciated - especially when trying to be compliant with AI governance policies that are becoming more common within large organizations. 

I will be curious to see if Appian adjusts how they manage AI pricing and token limits going forward, given that Sonnet 4.5 costs 3x Haiku 4.5 per token. As far as I know, Appian’s current token limits don’t distinguish between tokens used by different models, but with this new update I think this could change in a way that incentivizes using cheaper models like Haiku.

Update since this was first written: Appian announced that they will transition to a new "AI Actions" pricing model starting in 25.4, where AI Actions are a measurement of complexity of AI tasks This moves away from the existing token-based pricing model. There aren't many details publicly available yet, but it seems possible that the choice of model could affect the number of AI Actions consumed by a request.

5: Incremental Syncs (25.2/25.3)

The update:  You can now sync smaller subsets of updated data throughout the day (as frequently as 15 min increments) in addition to or instead of full syncs.

Why it made the list:  This addresses a major showstopper for using synced records with external data. Previously, you had two options: a full nightly sync (meaning data is stale) or a complex process-based sync using the Sync Records Smart Service. The latter required convoluted logic to detect updates and signal Appian, often making the effort outweigh the benefit. Incremental syncs offer a nice middle ground. You can run frequent syncs (down to 15-minute intervals) that only pull data based on a timestamp change, keeping your data closer to real-time. It doesn’t solve every edge case, but it removed a big hurdle that kept developers away from synced records.

4: Drag and drop grid row (25.1)

The update: Editable grid rows can now be reordered with an intuitive drag and drop experience.

Why it made the list:  This was easily the feature I was most excited for and shocked by when I saw it. Drag and drop functionality is something end users have asked for since I started working with Appian over 10 years ago. If you wanted to reorder grid rows previously you’d need to use either up/down icons, or some other unintuitive mechanism. Admittedly this single feature isn’t the most useful on its own, but my hope is that it opens the door to a broader range of drag and drop features going forward, like the ability to drag and drop entire components.

3: Customize AI prompts at runtime (25.3)

The update: You can now dynamically provide the prompt to use when calling the Execute Generative AI Skill smart service.

Why it made the list:  Previously, prompts were defined within the AI skill object itself - meaning any time it was executed, it used the same prompt (with a dynamic input). To work around this you might’ve needed to create several similar but very slightly different AI skills to address a use case, and even then it wouldn’t have fully solved the problem. This update was a big push in shifting my perception of Appian’s generative AI skills because it allows for much more flexibility in solving dynamic use cases. There are still many scenarios when I would prefer to use a 3rd party AI vendor, but Appian's 2025 investments into AI skills have started to win me over.

2: Hide the record header (25.4)

The update: Record views can now be totally customized by hiding the header title, views, and related actions.

Why it made the list:  Hiding the record header is something I’ve been waiting to see for years. It’s not the most impactful update of 2025, but it’s been a consistent thorn in applications I’ve worked on since Appian came out with Sites. 

Something that makes records in Appian special is that each record has its own URL. This is useful for a variety of reasons - you can bookmark a record view, share the URL with a colleague, and also navigate back/forth in your browser in a meaningful way. Regular interfaces in Sites can do something similar now with dynamic URL parameters, but there are still reasons why you might prefer to use records. The downside of records was that you were always stuck with the header, which can be jarring when navigating a Site. 

Say for example you have a Site with a custom left-hand navigation sidebar. Previously, clicking into a Record Type forced the standard Record Header to appear above your sidebar, breaking the layout and immersion. To avoid this, developers often abandoned Record Types in favor of custom interfaces, losing out on native record features like dedicated URLs. Now, you can get the best of both worlds: hide the header to maintain your custom layout while keeping the seamless transition from interface to record and retaining all out-of-the-box record benefits.

1: Sync up to 50 million rows per record type (25.4)

The update: Synced record max row limit is now 50 million rows. You can also query more related data. And performance of synced records is significantly improved. Not to mention several other smaller updates Appian has made to synced records this year.

Why it made the list: I already mentioned a couple of data fabric features that I liked from 2025, this top spot encompasses all of the other improvements to reiterate how fully on board I am with data fabric and synced records being the standard going forward, and to convince you that you should feel the same. The max row limit is now up to 50 million—up from just 4 million in 24.4. The row limit used to be the quickest way to dismiss synced records, but at 50 million, that objection has effectively vanished for the vast majority of enterprise use cases.

Honorable mentions - Process autoscaling, Process HQ

Process autoscaling and Process HQ both have received considerable attention in 2025. They have clear value in certain settings and I am eager to try them out, but they’ve yet to be a good fit for the particular projects I’ve worked on this year.

The wild card - a!callLanguageModel

This new function didn’t even get its own section in the 25.4 release notes, it’s just barely mentioned in the context of the new chat component.  a!callLanguageModel() lets you call the default generative AI model. The main intention seems to be that you would use it within the a!chatField, but it’s not specifically restricted to that. You can use it elsewhere on an interface - whether it be in the save of another component or even in a local variable. 

As far as I know this is the first time in Appian we actually have the ability to call Appian’s AI model outside of a process model. You could use an a!startProcess within a save to call a process with the Execute Generative AI smart service, but that is fairly slow, and a!startProcess can only be used within certain contexts. a!callLanguageModel should be faster without the overhead of a process instance running, and it can be called outside of saveIntos. However it is still fairly slow, potentially too slow to use on a user interface. It’s also something that needs to be used cautiously to avoid running too frequently on form reevaluations. 

One other interesting note is that unlike Prompt Builder, it does not seem to have Appian’s built-in system prompt. If you ask Prompt Builder to tell you about itself, it refers to itself as Appian’s Private AI. If you try this with a!callLanguageModel, it identifies as Claude. This suggests we are hitting the model more directly, bypassing Appian's internal system-prompt which could possibly have unintended consequences on outputs. At the end of the day I would still use a 3rd party AI provider if I wanted to use AI within an Appian interface, where I’d have more control over the inputs and likely have much better performance. But this one is definitely an interesting one to watch, especially if and when the performance of Appian’s AI improves.

Did not make the cut -  Case Management Studio, Composer

Case Management Studio continues to evolve, but I still struggle to find the right fit for it in my projects. The way it’s marketed often portrays it as giving business users the ability to manage their workflows in production, but in reality, it’s meant for business users to assist with development in a lower environment.

Another concern is the upgrade path. Unlike core Appian features, CMS is installed by importing an application package with standard design objects. The original understanding was that the “base” CMS platform would remain unchanged, allowing Appian to release new features as separate modules that you could install as needed. This idea fits CMS well, because it lets you customize the base design objects without worrying about future conflicts. However, CMS 2.0 broke that pattern by updating the base objects.

If I were to use CMS, I know I’d want to make customizations. If I had, upgrading to 2.0 would be a nightmare of trying to reconcile conflicts between those customizations and the updated base objects. That level of maintenance risk makes me hesitant to recommend CMS at this time.

Composer I can see as being a fun tool to add interactivity during a Sprint 0 session. I like the idea and I can see why Appian made it, but I wouldn’t rely on it for assisting in development. The times I’ve tried it, it has taken a while to modify the planned objects to the point where I’d rather create the objects myself from scratch.

In Conclusion

2025 was a great year for synced records AI, and UI in Appian. Several other new features have the potential to change how we build solutions in Appian, so I am excited to see how the platform continues to evolve in 2026 and beyond!