Frends Roadmap

Frends comes with a dedicated API Portal — a new add-on web app designed to simplify how your APIs are shared, documented, and consumed. Whether your users are internal developers, partners, or external clients, this portal offers a clean, unified experience for exploring and onboarding to your APIs.

Think of it as the storefront for your integrations — customizable, self-service, and always up to date.

What’s new:

🧑‍💻 API Consumer Onboarding
Users can register and access APIs via identity providers of your choice — making onboarding secure and frictionless.

📦 API Products
Group your APIs into logical, reusable products — whether native to Frends or wrapped via passthrough management.

🔍 API Discoverability
Easily publish and browse available API Products through the Portal’s intuitive UI.

📝 Lightweight CMS
Write and manage help content, onboarding guides, and marketing blurbs directly in the Portal using Markdown.

🎨 Whitelabeling
Customize the look and feel of the Portal to match your brand — logos, colors, fonts, and more.

Why it matters:

✅ Faster Developer Onboarding
Developers get what they need — faster. No more back-and-forth emails or lost API specs.

✅ Better API Governance
API Products give structure to how your APIs are offered and consumed.

✅ Looks Like You
Whitelabeling ensures the Portal fits your brand — whether you’re exposing APIs internally or to partners.

Frends already enables powerful Business Process Automation, including support for long-running workflows. Today, these are typically built as multiple interdependent Frends processes, each handling a step in the journey. While effective, the logic often lives across several process definitions — making the big picture harder to follow.

This new feature brings it all together.

Now, you can model the entire business process — even long-running, asynchronous flows — in a single visual BPMN diagram. It’s not just technically streamlined; it’s also easier for business stakeholders to understand, follow, and trust.

Frends processes can pause, wait, and continue across long time. This new feature set allows you to chain multiple Frends processes together using correlation identifiers, making long-running and event-driven workflows a breeze.

Imagine a process that starts today and continues when a file arrives next week. That’s now possible — with full-state persistence.

What’s new:

⛓️ Chained Process Execution
You can link separate Frends processes together using correlation variables (like an OrderID). Each part can run independently — days or weeks apart — but stay logically connected.

⏱️ Timer Shape
A brand new BPMN shape that lets you pause a process for a specified time. Think “sleep until next Tuesday.”

📨 Wait for Signal Shape
Pause your process until an external signal tells it to resume — whether from the same process or another one entirely.

📡 Send Signal Shape
Send a signal to resume a specific paused process instance — great for connecting async flows.

🧠 Stateful and Durable
All data is saved between steps, meaning your paused processes remember everything — securely and reliably. You decide the persistence point - this way we do not sacrifice the performance.

Why it matters:

✅ Flexible Orchestration
Break down big processes into manageable parts that sync on your terms.

✅ Async Made Easy
Handle scenarios with variable delays — like external approvals or delayed data inputs.

✅ Low-Code, High Power
All of this happens right inside the familiar BPMN Editor.

Today, Frends orchestrates complex business processes and integrations — but what if your AI agents could discover and call those processes as tools? With Frends MCP Trigger, you can expose any Frends Process as a Model Context Protocol (MCP) tool, making your automation workflows instantly discoverable and callable by AI agents. No custom APIs, no middleware — just configure a trigger, and your processes become intelligent tools that AI can orchestrate on demand.

How It Works

The MCP Trigger transforms Frends Processes into standardized tools that follow the Model Context Protocol specification. When you add an MCP Trigger to a Process, you define its tool signature — including name, description, input schema, and optional output schema. Frends automatically exposes an MCP-compliant endpoint (e.g., https://agent-host/mcp) that responds to JSON-RPC requests from AI agents.

Example scenario: An AI assistant needs to check inventory levels and create purchase orders. Instead of building custom integrations, it discovers your "CheckInventory" and "CreatePurchaseOrder" Processes via MCP's tools/list call, reads their schemas, and executes them via tools/call — all secured by Frends API Policies. The AI agent gets structured responses, logs every action, and your business logic stays centralized in Frends.

This feature lays the foundation for Agentic AI orchestration — where AI agents autonomously compose and execute business workflows using your existing Frends Processes as building blocks.

What's new:

🤖 MCP Trigger Configuration — Define your Process as an AI-callable tool with name, description, input/output schemas, and behavioral annotations (read-only, idempotent, destructive).

🔍 Automatic Tool Discovery — AI agents can query tools/list to discover all available Frends Processes exposed as MCP tools, complete with schemas and metadata. Each Frends Agent then act as an own MCP Server.

📞 JSON-RPC Tool Execution — Agents call your Processes via standardized tools/call requests, passing parameters and receiving structured responses.

🛡️ API Policy-Based Authentication — Secure MCP endpoints using Frends API Policies with virtual URL routing (/mcp/<call>/<identifier>), ensuring only authorized agents can discover and execute tools.

📋 Schema-Driven Contracts — Define JSON Schema for inputs and outputs, enabling AI agents to validate parameters and understand response structures before execution.

🎯 Behavioral Annotations — Mark tools as read-only, idempotent, destructive, or open-world, helping AI agents make informed decisions about when and how to use them.

Why it matters:

✅ C-Level / Business Impact: Unlock AI-driven automation without building custom agent infrastructure — reduce time-to-market for intelligent workflows and maximize ROI on existing Frends investments.

✅ Architect / Technical Value: Achieve full governance and auditability for AI agent actions — every tool call is logged, secured, and traceable through Frends' existing monitoring and API management.

✅ Developer Experience: Expose Processes as AI tools with zero custom code — just configure a trigger, define schemas, and let AI agents orchestrate your workflows visually and transparently.

✅ Future Direction: Establishes the foundation for Agentic AI orchestration — where autonomous agents compose, execute, and optimize business processes using Frends as the intelligent automation backbone.

After hundreds of customer votes and requests, Frends is getting a brand-new Visual Data Mapper — bringing a faster, more intuitive way to transform data between formats and schemas. No more fiddling with manual logic or raw JSON — just drag, drop, and let the platform do the heavy lifting.

Whether you're working with APIs, files, or internal data structures, mapping fields is now visual, smart, and low-code friendly.

What’s new:

📄 Automatic Schema Detection
Paste in your JSON, XML, or other structured data — Frends will infer the schema instantly, so you can start mapping right away.

🧠 AI-Assisted Mapping
Use the built-in AI Assistant to auto-generate mappings between source and target structures. Just say “map this to that” — and watch it go.

🧩 Low-Code Support
Need more control? You can still apply C# logic to any field or transformation, just like in existing Frends processes.

Why it matters:

✅ Faster Integrations
Skip the boilerplate — go straight from data source to output with visual clarity.

✅ Business-Friendly
Non-developers can now participate in data mapping without touching a line of code.

✅ AI + Low-Code = 🔥
Let AI handle the boring bits, then tweak the logic exactly how you need.

Frends already empowers users with powerful low-code configuration capabilities, enabling visual integration design through BPMN 2.0 and AI-assisted development. Today, users can create integrations using our intuitive platform with LLM-based code generation, task configuration, and visual data mapping. While effective, developers often need to write custom C# code for complex data transformations, loops, and conditional logic — making development more technical than it needs to be.

This enhanced low-code experience takes our proven approach to the next level.

Now, you can handle even the most complex data scenarios without writing a single line of C#. From automatic schema detection to native support for loops and conditional statements — it's all built right into the familiar low-code interface that business technologists and developers already love.

What's new:

🔍 Automatic Data Schema Detection
Simply provide sample data during development, and Frends automatically determines the data lineage and schema. This enables fully qualified IntelliSense across all current Frends Tasks — making configuration faster and error-free.

🔄 Support For Complex Loops
Iterate through complicated arrays and collections directly in your low-code configurations. No more custom C# for complex data processing — just point, click, and loop.

🤔 Support For IF/ELSE
Create native conditional statements right in your low-code references. Handle missing data, complex mappings, and interconnected dependencies without touching code.

✨ Intuitive Syntax
All enhancements use the familiar double handlebars ("") syntax you already know — ensuring seamless adoption into your daily workflow.

Why it matters:

✅ Faster Development Eliminate custom coding for common scenarios like loops and conditionals
✅ Better IntelliSense Automatic schema detection provides smart suggestions across all tasks
✅ Lower Barrier to Entry Business technologists can handle complex scenarios without developer assistance
✅ Consistent Experience Familiar syntax means no learning curve for existing users

Current Frends version provides powerful unit testing capabilities that help developers validate individual components of their integration workflows. Today, teams can test specific tasks and processes in isolation, ensuring code quality at the component level. While effective for catching basic issues, testing complex integration workflows end-to-end often requires manual processes, custom test logic, or external tools — making it challenging to ensure integrations work reliably across entire business processes.

This new native capability brings comprehensive test automation directly into the platform.

Now, you can visually design, manage, and automate complex test scenarios for your entire integration workflows — all without leaving Frends. With an intuitive "paint-to-test" approach, simply select any part of your integration, provide test data, and define success criteria. It's testing made as visual and accessible as the integrations themselves.

What's new:

🎨 Paint-to-Test Interface
Select any part of your integration workflow visually, provide test data, and define success criteria. No scripting required — just point, click, and test.

🔄 Automated Test Execution
Run tests manually on-demand or trigger them automatically as part of your deployment pipeline. Full integration with your development lifecycle.

📊 Test History & Analytics
Complete test execution history with detailed statistics and reporting. Track test performance, identify trends, and maintain quality metrics over time.

🔗 End-to-End Coverage
Test entire business processes from start to finish, including complex workflows with multiple systems, data transformations, and business logic.

♻️ Reusable Test Scenarios
Create test templates that can be reused across similar integrations, reducing setup time and ensuring consistent testing standards.

Why it matters:

✅ Increase Quality & Reliability Catch issues earlier and reduce production errors with comprehensive automated testing
✅ Accelerate Development Cycles Eliminate manual testing bottlenecks and release updates faster with confidence
✅ Lower Total Cost of Ownership No need for custom testing frameworks — everything is built-in and ready to use
✅ Enterprise-Ready Perfect for System Integrators and enterprise customers who demand high-quality, reliable services

Today's Frends Intelligent AI Connector executes prompts — you send input, get output, move on. But what if your AI could think, reason, and learn across multiple steps? Frends Intelligent AI Connector v2 transforms single-shot AI execution into true Agentic orchestration. Now your AI doesn't just respond — it reasons through problems, dynamically calls MCP tools, remembers context across steps, and adapts its approach until it achieves the goal. This is AI that acts like a teammate, not just a function call.

How It Works

The Intelligent AI Connector v2 introduces ReAct-style reasoning loops directly into your BPMN flows. When the AI Connector executes, it doesn't just run once — it enters a reason-act-observe cycle, where it evaluates the situation, selects and calls MCP tools, analyzes results, and continues reasoning until it completes the task or reaches your configured depth limit.

Example scenario: An order arrives with incomplete shipping data. The AI Connector reasons: "I need postal code validation." It browses available MCP tools, discovers your "ValidateAddress" Process, calls it, receives a corrected address, then reasons again: "Now I can route to the correct warehouse." It calls "SelectWarehouse," evaluates inventory, and finally triggers "CreateShipment" — all autonomously, with full audit trails. If you assign a memory chain (e.g., chain:orderProcessing), subsequent AI steps in the same process run remember previous decisions, creating truly adaptive workflows.

Before execution, you see estimated Frends Credits consumption based on your model choice, reasoning depth, and expected context size — no surprises, full cost transparency.

This positions Frends as the most advanced AI orchestration layer in the iPaaS market — where AI doesn't just integrate systems, it thinks, reasons, and improves.

What's new:

🧠 ReAct Reasoning Loops — AI performs iterative reason-act-observe cycles, dynamically refining its approach until task completion or depth limit reached.

🔧 Visual MCP Tool Selection — Browse and select MCP-exposed Frends Processes directly in the AI Connector UI — no manual API configuration or trigger chaining required.

🧵 Memory Chaining — Assign named memory contexts (e.g., chain:customer) so AI steps remember and build on previous reasoning within the same process run.

🎚️ Configurable Reasoning Depth — Set max reasoning iterations (1-10 levels) per connector, balancing execution speed, intelligence, and cost.

💰 Frends Credits Estimation — See real-time cost preview before execution, dynamically calculated from model selection, reasoning depth, and context size.

📊 Transparent Reasoning Traces — Every reasoning step, MCP tool call, and decision is logged and auditable — full visibility into AI's thought process.

Why it matters:

✅ C-Level / Business Impact: Deploy adaptive, self-improving automation that reduces manual intervention by over 70% — AI handles exceptions, refines decisions, and learns from context, delivering measurable ROI with predictable costs.

✅ Architect / Technical Value: Achieve full governance over AI reasoning — every loop iteration, tool call, and memory access is traced, secured via API Policies, and auditable for compliance and debugging.

✅ Developer Experience: Build intelligent workflows visually — no custom AI orchestration code, no manual prompt chaining, just drag, configure depth and memory, and let AI reason through complexity.

✅ Future Direction: Establishes the foundation for self-optimizing processes — where AI continuously learns from execution history, adapts to changing conditions, and evolves business logic autonomously

For more information about Autonomous AI Agents see the following Gartner research: https://www.gartner.com/en/articles/intelligent-agent-in-ai

Current Frends can run prompts in ChatGPT tasks, but next, AI will go native in Frends. With our upcoming Native AI Task feature, you can embed Large Language Models (LLMs) like Azure OpenAI directly into your integration processes — no external services, no custom glue code. Just drag, drop, and orchestrate AI like any other BPMN task. You can also use pre-trained AI models from Hugging Face, which are easily available.

By orchestrating prompts together with Frends Tasks and Connectors, you can take the first step of the Agentic AI Approach.

• BPMN 2.0 with AI Native Tasks enables AI Orchestrations. Practically, you can implement the thought process of an employee as steps and decisions. 
• Frends Triggers already cover every system - so triggering the through process specific to an input is now possible. 
• Pour in Frends APIs in the thought process as actions of the AI employee. 

For example 

A support mail triggers a Frends AI process. Initial categorization is done with an LLM prompt. Is it a billing issue? Is it a tech incident or an access problem? Or a service request? Frends BPMN2.0 exclusive decision then routes the process to a corresponding path. If it is a tech incident, the next LLM step can be done. Itil Categorization with a pre-trained existing model in the next single LLM prompt step. If the AI step is prompted to gather logs, Frends basic Task will do that. The whole process for multiple different ticket cases can be written as a series of prompts, decisions, and actions. Future Frends features will expand the AI steps to do the API calls internally inside the AI step and even enable the Computer Use Access to finalize the Agentic AI path. These two steps will be included later on in our roadmap. With Native AI Task, you can already start your agentic AI journey. 

What’s new:

🧠 Native AI Shapes
Drop AI tasks directly into your BPMN flows. Build chat-like logic, classification steps, or dynamic decisions with zero code.

🔗 Prompt Chaining
Connect multiple AI steps in a single process — each using the output of the last to create intelligent, context-aware flows.

🚀 Pre-Trained Models
Use Azure OpenAI by default, or bring your own models from Hugging Face — no fine-tuning needed.

📈 Usage Tracking & Cost Controls
Track AI usage during dev and production. See inputs, outputs, and reasoning paths — keep control of performance and spend.

📊 Monitoring & Transparency
Frends will show you exactly what the AI saw, said, and decided — audit-friendly, debug-ready, and crystal clear.

Why it matters:

✅ Smarter Automation
Let AI handle tasks like summarization, routing, or intent detection — and make your processes more autonomous.

✅ Low-Code, No Hurdles
All AI logic is visual, editable, and doesn’t require managing session state or custom scripts.

✅ Ready to Scale
Automate more, faster — and stay in control of both outcomes and costs.

We’ve rebuilt the Frends start page and onboarding experience into something much smarter (and friendlier). Whether you’re a Frends veteran or a total newbie, you’ll now land on a page that knows what you need next — and actually helps you get there.

The new start page isn’t just a dashboard — it’s a command center. Think guided tours, smart search, and helpful widgets. Everything is designed to help you explore, build, and feel right at home.

It´s a Welcome That Actually Welcomes. 😍

What’s new:

📚 Smart Starting Page
You now land on a page showing where to begin, what to try next, and how you’re doing. A handy onboarding widget guides your journey right from your first login.

🔍 Global Search, Zero Friction
The new search bar is a power tool. Instantly find Templates, Processes, APIs, Environment Variables, Users, and more — from anywhere. Plus, toggle between list and grid views because, hey, you deserve options.

🧠 Your Onboarding Assistant
Not sure what to do next? There’s now a dedicated onboarding page that lists all available tutorials, tracks your progress, and helps you level up, step-by-step.

💡 Built-in Feedback Loops
Want to suggest a feature? Found a bug? There are now dedicated pages just for that — pre-filled with your info so you can submit in seconds.

🧭 Behind the Scenes: Base Architecture
We created a flexible, containerized front page structure and backend APIs (controllers) that make all of this magic possible. Think of it as scaffolding for even more smart features to come.

Passthrough APIs provide a way of more easily configure API calls to be forwarded to backend system and ways of monitoring these calls

• Passthrough API functionality to enable users to easily configure existing API’s to be governed by Frends API Management without having to have an underlining Frends process attached to the API.

  • The passthrough API will have simplified configuration capabilities to modify:

    • HTTP Headers

    • Authentication methods

    • URL paths and parts

• Improved API Monitoring capabilities

  • Introduce new API Monitoring views to show more API relevant data such as HTTP response codes as well as better ways to view the overall API health and execution statistics

API Policies

We are introducing Unified API Policies, designed to centralize and streamline access management for all API’s while preparing for the upcoming release of the Frends API Portal.

Key Enhancements:

• Unified Policy Configuration: With Unified API Policies, you can easily configure access restrictions and throttling for all your APIs through a single, user-friendly mechanism.

• Throttling and Access Control: Tailor API Policies to meet your specific needs. Define access limits and throttling rules to ensure optimal API usage and prevent abuse.

• Adaptable to Any Authentication Method: API Policies are versatile and can be applied to APIs regardless of the authentication method used, providing consistent control and management.

New Authentication Method: Private Application Registration

Additionally we are introducing a new authentication method to work with the reworked API Policies: Private Application Registrations.

Key Enhancements:

• Secure Authentication: Private Application Registrations supersede API Keys, offering a more secure and modern authentication solution.

• Static JWT Tokens: These tokens are essentially static JSON Web Tokens (JWT) containing user-provided data about the API consumer, alongside digital signatures to ensure data integrity.

We are introducing an advanced feature within Frends that enables users to create Code shapes efficiently through natural language prompts. This enhancement streamlines the process of writing C# code to perform complex integration tasks within your integration processes.

Key Enhancements:

• Contextual Information: System prompts are integrated to provide contextual details for process configuration, including environment variable names, process variables, trigger variables, and access to task results.

• Seamless Integration: When opted in the Process Editor seamlessly connects to our LLM service (Azure Open AI) for effortless use.

• Tenant-Specific Configuration: For security and flexibility, each Frends tenant will utilize it’s own dedicated instance of the LLM model for context and session security.

We are introducing a powerful new capability within Frends that enables users to generate process descriptions and documentation with ease, using the Frends Large Language Model (LLM). This feature simplifies the process of creating detailed descriptions for your Processes.

Key Highlights:

• Description Creation: Users can initiate the process by simply clicking a button to have the Frends LLM generate an initial Process description and documentation based on the BPMN Process designed, variables and Tasks used as well as any user provided documentation.

• Fine-Tuning with Additional Prompts: After receiving the initial response, users have the flexibility to provide additional prompts to further refine and customize the generated description.

Building on the previous feature of LLM Code Generation we are also introducing a feature that allows users to configure Tasks seamlessly through natural language prompts. This simplifies the process of configuring Task parameters, creating low-code mapping configurations and utilizing Task results and other variables when configuring Frends tasks.

Key Highlights:

• Effortless Task Configuration: Users can effortlessly configure Tasks by describing the required functionality for the task using plain language, eliminating the need for manual configuration.

• Contextual Continuity: This feature retains the chat context, enabling users to iteratively enhance Task configurations within the same conversation as well as test out their configuration at any time.

• Tenant-Specific Configuration: For security and flexibility, each Frends tenant will utilize it’s own dedicated instance of the LLM model for context and session security.

We are introducing a valuable enhancement to the Frends Process Editor by incorporating Decision Model and Notation (DMN) functionality. DMN provides an efficient means of mapping data and decision-making, as described in detail here.

Key Enhancements:

• DMN Shape Integration: With this feature, we are introducing a dedicated DMN shape within the Frends Process Editor. This shape will allow users to create input maps following the table structure outlined in the Wikipedia article.

• Mapping to Frends Variables: Users can easily associate DMN inputs with various Frends variables, streamlining the data mapping process.

• Output Generation: The result of the DMN shape will provide corresponding outputs based on the input configurations ready to be used in following integration tasks and steps.