Major Features
Intent AI MCP Connection
Tell the AI agent your team already uses what you need, and get back a working application to review and publish.
A Better, Faster Aurachain. One Standard Across Every Screen
A better, faster Aurachain, now running on one design system across the design areas and the screens your teams work in.
AI Agent Builder
Set up an AI agent once, then add it wherever you need one and prompt it for the job at hand.
AI Agents in Document Templates
Documents write their own sections, from the process data gathered along the way.
Dynamic Task Reminder Notifications
Reminders that run off the real deadlines in your application, so people are prompted before time runs out.
Additional Enhancements
Round-robin task assignment across a defined group of users Auto-retry for failed notifications, with a paged retry log Reusable Functions now callable from inside document templates Data transfers defined once and previewed before anything changes Process Controller available at application level, without full admin rights
Aurachain 4.0
A new look, a new way to work!
Aurachain is the execution layer where regulated institutions turn obligations, risk signals, and fraud alerts into governed, audited action. Version 4.0 is the largest release in the platform’s history: a full redesign, a new way to create and run applications with AI, and the same audited control underneath it all.
This new version was inspired by the institutions running on it. Years inside compliance, risk, and fraud teams taught us where the work snags: the handoff between designing a process and running it, the rebuild every time a rule changes, the evidence assembled after the fact. Customers told us what they wanted; 4.0 is what we built.
In 4.0, designing a process, changing it, and running it all behave like the same product, because they now are. One design system carries from the build areas through to the screens your teams work in every day. The path from an obligation to a live, working application is continuous.
AI sits inside the work, not beside it. Describe what you need to the AI agent your team already uses, and Aurachain returns a working application: the process, the screens, the data model, the documents. Your people review it and decide what goes live. Agents live in one place inside the application, configured once and placed wherever the work needs them.
Underneath the new experience, the platform holds the same governance it always has. Approvals, versioning, access control, and a complete audit trail run by default on everything 4.0 generates, including the applications the AI creates for you. The experience changed. The records you need did not.
Intent AI. Describe the Application, and Aurachain Designs It
Intent AI connects the AI agent your team already uses to Aurachain through MCP. You describe what the application needs to do in plain language and your AI agent designs it inside Aurachain: the process, the screens, the data model, the documents and the agents inside it.
It designs with the same modules your teams use, so anything an AI agent produces, a person can open and keep working on. Your access rules still apply. Your teams review the result before anything goes live. The same works for an application already running: describe the change, and your AI agent implements it.
How it works
- Connect your AI agent. Any AI agent that supports MCP, signed in with your own Aurachain account.
- Describe what you need. A new application, a single screen, or a change to something you already run.
- Aurachain designs it. The work appears in your Aurachain environment, ready to open and inspect.
- Review and publish. The process owner checks the result, makes adjustments and decides what goes live.
Benefits
- Start from a sentence: describe what you need instead of designing it screen by screen.
- Any size: one request covers a full application, a single process or one screen.
- Changes carry through: a rule changes and the update reaches every place it touches, without anyone hunting for them one by one.
- Model agnostic: works with any AI agent that supports MCP, so your teams keep the one they already use.
- Human in the loop: your AI agent designs it, a person reviews and publishes.
Use Cases
- A new AML rule lands and your KYC process needs three extra checks. Just ask your AI to add them.
- Disputes are piling up and you need a second review before refunds go out. Just ask your AI to add the step.
- Your risk thresholds change and the new values need updating in 100+ places. Just ask your AI to update them everywhere.
- Sanctions screening moves to a new provider and every process that touches it needs rewiring. Just ask your AI to rewire it.
A Better, Faster Aurachain. One Standard Across Every Screen
Aurachain 4.0 brings a refreshed interface, remodeled screens and a cleaner experience across the product. From the way you design, to the way you solve tasks, manage applications and teams or view your reports, everything in Aurachain 4.0 delivers a better experience.
Benefits
- Easier to learn. New people find their way sooner.
- Predictable screens. Components behave the same way wherever they appear.
- Less clutter. Attention stays on the work rather than the interface.
- Learn it once. A pattern you pick up in one part of the platform holds everywhere else.
AI Agent Builder. Configure an Agent Once, Use Anywhere
One place to set up and manage the AI agents in your application. Configure an agent once with its instructions, its limits and what it can reach. Then add it anywhere the application supports one, and prompt it for the job that spot needs. The same agent can answer questions in a screen, decide inside a process step and write a section of a document, because the setup travels with it and the prompt is yours to write each time.
Where agents work
1. In user interfaces: agents work inside the screens people use, answering questions and filling in fields as the work happens. The person stays in the interface and the agent responds in place.
2. In process flows: agents run as a step in the process, drafting or deciding before the work moves on. The output is passed along like any other process data.
3. In document templates, new in 4.0, agents write whole sections of a generated document from application data.
How it works
- Connect a model once for everyone to use. Choose from OpenAI, Azure OpenAI or Anthropic.
- Configure your agent by setting instructions and limits.
- Test it first. Try the agent in the built-in test panel before anyone else relies on it.
- Use it anywhere. Call the same agent from processes, pages and documents across the application.
Benefits
- Set up once. Configure an agent one time, then call it from anywhere in the application.
- One agent, many jobs. The prompt you write in each place decides the work it does there.
- One place to control. Model connections and keys sit in a single admin area, under one owner.
- Nothing goes live untested. Try the agent in the built-in panel before anyone relies on it.
- Full version history. Every change is kept, so you can show what the agent did and when.
Use Cases
- A review is finished and someone has to write it up. The agent drafts the narrative from everything gathered along the way.
- An analyst is mid-review and needs to know what the policy says. The agent answers in the screen, from your approved documents.
- A customer sends in a document and it has to be checked against the record. The agent reads it and flags what does not match.
AI Agents in Document Templates. Documents That Write Their Own Sections
Agents configured in the AI Agent Builder can now write paragraphs, sections or whole chapters inside a document template. The generated content is placed straight into the document and can draw on application data gathered during the process.
How it works
- Configure your agent. Set it up in the AI Agent Builder with instructions for this kind of writing.
- Place it in the template. Add the agent where the section should appear.
- Produce the document. The agent writes the section and the document is generated with it in place.
Benefits
- Faster drafting. Complex documents arrive written rather than assembled by hand.
- Consistent wording. Documents of the same kind read the same way every time.
- Less rewriting. Fewer rounds of copying and editing before a document is ready.
- Reviewed before it goes out. A person checks and approves every document.
Use Cases
- A KYC review reaches the point where the customer risk assessment is produced. The agent writes the rationale into it, from the checks and findings the process has already recorded.
- An alert is dispositioned and the process generates the report for filing. The agent writes the narrative section from the activity, the account history and the analyst’s findings.
- A vendor due diligence review ends and the process produces the approval memo. The agent writes the risk summary into it, from the questionnaire answers and the documents collected along the way.
Dynamic Task Reminder Notifications. Deadlines That Follow Up on Themselves
Schedule email reminders that use the real business dates stored in your application, such as contract end dates, service targets and submission deadlines. Reminders can run while a task is open or for as long as the process is active, and go to task owners, named users, groups or recipients drawn from process data.
Benefits
- Fewer missed deadlines. People are prompted before the date, rather than after it.
- Reduced manual follow-up. Automated reminders help reduce the need to track deadlines and send individual follow-up messages.
- Consistent application. The same reminder logic can be applied consistently across relevant tasks and processes.
- Relevant information included. Each reminder can include the key details needed to keep recipients informed.
- Your wording. Full control of subject, body and template, including process details.
USE CASES
- Contract deadline approaching: reminders use the contract end date held in the application and go to the customer and the account owner, so renewals are actioned in time.
- Compliance milestone about to expire: a reminder runs while the task is still open, timed from the milestone date and copied to the responsible group.
- Service target about to be missed: reminders run for as long as the process is active and reach the task owner and the wider team before the deadline.
Round-Robin Task Assignment. Every Task Gets an Owner, in Turn
Incoming tasks are shared out in turn across a defined group, in the alphabetical order of its users. Once everyone has had one, the sequence starts again. Round-robin joins claiming, direct assignment and rule-based assignment as a way of allocating work, and runs alongside claiming rather than replacing it.
Benefits
- Less admin. Team leads stop allocating work by hand every morning.
- Predictable split. The order is visible and the same for everyone in the group.
- Owner on arrival. Work starts moving instead of waiting in a shared queue.
- Nothing stranded. Fewer items left unclaimed at the bottom of the list.
Use Cases
- Alerts arrive through the day and each one needs an owner. Every alert goes to the next analyst in sequence.
- Onboarding reviews are piling into a shared queue. Files are dealt out in turn across the reviewer group.
- Disputes come in overnight and nobody has been assigned. Each one has a named owner by the time the team logs on.
Data Transfers. See the Change Before It Happens
Move data between Aurachain and your applications in one defined transfer rather than a chain of manual edits. Set the conditions that decide which records are touched, preview exactly what will change, then run it. Every run is versioned and logged.
WHAT YOU CAN DO
- Add, update by conditions, delete or read audit records on a data table.
- Map screen elements or fixed values to columns, and set the conditions.
- Preview the matching records and totals before anything changes.
- Create a transfer straight from the interaction that will use it.
Benefits
- One definition. The same transfer serves every screen that needs it.
- Only what you intend. The conditions decide exactly which records are touched.
- Confirmed before it runs. You see what would change before anything does.
- Logged and versioned. Every run is recorded and the history is kept.
Use Cases
- Creating records from a screen: a transfer maps the screen elements to columns and adds one row for each item.
- Updating many records at once: one transfer updates every record matching the conditions you set, in place of record-by-record edits.
- Checking before go-live: the built-in test previews the matching records and totals, so teams confirm the outcome before running it.
Reusable Functions. Now Reaching Document Templates and Data Tables
Write a rule once and run it everywhere it belongs. A Function now works inside document templates and drives data tables directly, as well as in your processes. Change the rule in one place and everything using it updates.
WHAT YOU CAN DO
- Insert a Function placeholder in a document template and map its inputs.
- Call data table actions directly from inside a Function.
- Pass complex, structured information in and out.
- Placeholders follow renames and flag Functions that changed or were removed.
Benefits
- One source. A rule is maintained in one place.
- Current values. Documents work out their figures as they are generated.
- Less duplication. Fewer copied scripts to fix later.
- Early warning. Broken templates are flagged before someone uses them.
Use Cases
- A risk score is used in three processes and two documents. Define it once and every use stays in step.
- A threshold changes and the calculation sits in a dozen places. Change the Function and all of them follow.
- A rule is edited and something downstream depends on it. The affected templates are flagged before anyone opens them.
Process Controller at Application Level. Test Your Own Processes
Process owners and managers can open the Process Controller for a single application from its own Analytics menu, without full admin rights. It works exactly like the full admin tool, limited to that application, and is granted through a dedicated permission under the Analytics tab.
Benefits
- No waiting. Your team tests its own work without booking an administrator.
- Faster sign-off. QA and business users see what a process actually did.
- Live diagnosis. Problems are found while the process is still running.
Use Cases
- A process is behaving oddly and nobody wants to raise a ticket. The owner opens the Process Controller and looks while it runs.
- A new version needs signing off before go-live. QA replays a run and inspects each step inside the application.
- Someone needs access to one application only. The permission covers that application, and platform-wide access stays restricted.
Standardized Date & Time. One Format, Read the Same Everywhere
Aurachain now applies one date and time standard across the platform’s own screens, following your interface language. Pickers, tables, lists and admin views all read the same way. Content your process owners set up, such as task names, generated documents and emails, keeps its own settings.
Benefits
- No guesswork. A date means the same thing wherever it appears.
- Values line up. The same date reads the same way on screen and in an export.
- What you pick is what you see. Entries display exactly as they were entered.
- Ready for regions. Groundwork for wider regional formats later.
Use Cases
- Tasks and dashboards: task lists, dashboards and activity history all follow the one platform standard.
- Pickers and data entry: pickers follow the interface language, so entry and display match and fewer entries are mistyped.
- Data views and catalogs: every table, catalog and data view presents dates to the same standard, so reports and exports line up.
Platform Improvements
- Auto-Retry for Failed Notifications
- Auto-retry for failed email notifications, using rules you configure.
- Paged retry log that loads as you scroll.
- Files in Automated Steps
- Automated steps can read, produce and attach files directly, so documents move through a process without manual handling.
- Variables in Interactions
- Interactions pass and reuse variables, giving designers finer control over what information moves between steps.
- Stability and Usability:
- Batched loading in retry logs, and a range of stability and usability fixes reported by teams on earlier versions.
More from Aurachain
More from Aurachain
From intelligence
to action.
Build the operating layer for compliance, risk and fraud. Orchestrate what matters. Protect what counts.
Talk to Aurachain