Ubby's general agents are powerful and versatile, but every business has its particularities. You probably have specific internal processes, proprietary tools, or sequences of actions that repeat exactly the same way. This is where custom agents reveal their full value.

A custom agent allows you to capture your organization's expertise and best practices into an agent that applies them consistently, every time. Rather than explaining your process to a new collaborator and hoping they follow it correctly, you create an agent that executes this process exactly as you defined it, without variation or oversight.

This personalization also transforms your relationship with Ubby. You are no longer just using a tool someone else designed, you are creating your own solutions adapted to your unique challenges. The more you invest in creating custom agents, the more valuable Ubby becomes to your organization, and the harder it becomes to imagine working without it.

Ubby offers you three main ways to customize your agents, each responding to a different need. You can use just one of these dimensions or combine them to create extremely sophisticated agents.

A custom workflow defines a sequence of actions that your agent must execute in a specific order. It is like creating a detailed recipe that the agent will follow faithfully each time it is launched.

Imagine your accounting firm has a monthly closing process that involves several steps in a precise order. You must first extract accounting data from Pennylane, then generate a preliminary report, send it to your manager for validation, wait for their feedback, make any necessary corrections, finalize the report, archive it in Google Drive according to your naming convention, and finally send a notification to your client. Each step depends on the previous one, and the order is critical.

With a custom workflow, you capture this exact sequence in your agent. Once configured, the agent executes all these steps in the right order, handles waiting points when necessary, and guarantees that no step is forgotten. What previously took two hours of manual work becomes an automatic execution that you can trigger with one click.

Triggers define the conditions that automatically start your agents without human intervention. Instead of having to remember to manually launch an agent, you configure the circumstances under which it should start, and it executes automatically when those conditions are met.

Triggers can be time-based, event-based, or based on specific conditions. A temporal trigger might automatically launch your document reminder agent every Friday at four in the afternoon. An event trigger might start an agent as soon as a new file appears in a specific folder on your Google Drive. A conditional trigger might launch an agent only for client files that have had missing documents for more than a week.

This complete automation transforms how you work. You no longer need to remember to do certain tasks at regular intervals. You no longer need to constantly monitor your systems to detect when an action is necessary. Your agents monitor for you and act at the appropriate moment.

Although Ubby integrates natively with more than two thousand seven hundred applications via the MCP protocol, you might use internal tools developed specifically for your organization. Custom connectors allow you to plug these proprietary systems into Ubby.

If your firm has developed its own internal CRM or uses highly specialized management software, you can create a connector that allows your agents to interact with these systems. Your agents can then read information from these tools, update data, create records, exactly as they do with standard applications.

This capability for total integration guarantees that Ubby can adapt to any technological infrastructure. You are not forced to abandon your current tools or migrate to different platforms. Ubby integrates into your existing environment, whatever its composition.

Creating a custom agent follows a structured methodology that helps you transform a business process into an autonomous agent.

Before configuring anything in Ubby, take time to observe and document precisely the process you want to automate. Follow a collaborator while they execute this task, or perform it yourself while noting every action you take.

Note not only the main actions but also the micro-decisions you make along the way. When you check if a document is complete, what criteria do you use exactly? When you decide to send a reminder rather than a first follow-up, what do you base this decision on? These details are essential for creating an agent that truly works.

Clear documentation at this stage considerably accelerates configuration and reduces the back-and-forth necessary to refine the agent.

Once your process is documented, break it down into distinct and logical steps. Each step should have a clear objective and a verifiable result. This breakdown helps you structure your workflow so the agent can follow and verify its progress.

For example, instead of defining a vague step like "prepare the monthly report," break it down into specific steps: connect to Pennylane, extract the month's transactions, filter transactions by category, calculate totals, create an Excel file with the predefined structure, generate graphs, format the report, save in the appropriate folder. Each step is concrete and verifiable.

With your process broken down, you are ready to configure it in Ubby. The workflow creation interface guides you through each step, allowing you to define actions, tools to use, data to manipulate, and the logic that connects everything together.

Ubby uses the Model Context Protocol, which means you have access to an immense library of pre-built connectors. Rather than having to program each interaction with each tool, you simply select the appropriate connector and configure the parameters specific to your use case.

For each step of your workflow, you define what should happen if this step succeeds and what should happen if it fails. This explicit error handling guarantees that your agent does not get stuck when something unexpected happens.

Once your workflow is configured, test it in a secure environment before deploying it in production. Ubby allows you to execute your agents in test mode where you can observe each step, see exactly what the agent does, and identify necessary adjustments.

Test with varied data to ensure your agent properly handles different scenarios. What happens if a file is missing? What does the agent do if an API does not respond? How does it react to unexpected data? These tests reveal edge cases you might not have anticipated during design.

Do not hesitate to iterate several times. The best custom agents are rarely perfect from the first version. Each cycle of testing and refinement improves your agent's reliability and robustness.

The Model Context Protocol is what allows Ubby to connect to thousands of different applications without you having to manage the technical complexities of each integration. Understanding how to use MCP effectively gives you access to an incredibly rich ecosystem of tools.

Ubby offers a library of MCP connectors organized by category. You can browse this library to discover which applications are already supported and which actions are available for each. Most common professional tools already have robust connectors you can use immediately.

When searching for a connector, think not only about the application name but also about the type of action you want to perform. Connectors often offer dozens of different actions for the same application. The Pennylane connector, for example, can extract accounting data, create invoices, update transactions, manage client contacts, and much more.

For an agent to act in your tools, it must be able to authenticate with these applications. Ubby handles this process securely, storing your credentials in encrypted form and using them only when necessary to execute the actions you have authorized.

The first time you use a connector for a given application, Ubby will guide you through the authentication process. Depending on the application, this might involve logging in via OAuth, providing an API key, or configuring an access token. Once this initial authentication is done, your agents can use this connector without additional intervention from you.

Each external API has its own limits and behaviors. Some applications limit the number of requests you can make per hour. Others have specific timeouts. Some fail unpredictably when they are overloaded.

Ubby automatically handles many of these complexities for you. If an API reaches its rate limit, Ubby automatically waits the necessary time before retrying. If a request temporarily fails, Ubby retries intelligently rather than immediately giving up. This sophisticated error handling is what allows your agents to function reliably even when external systems are unstable.

To give you a better idea of what is possible, here are some examples of custom agents our clients have successfully created.

This complex workflow begins by connecting to Pennylane and extracting all transactions for the relevant quarter. The agent then filters these transactions according to applicable VAT rules, calculates deductible and collected amounts, generates a draft declaration according to the appropriate form, and sends it to the firm's manager for validation.

The workflow includes a waiting point where the agent waits for the manager to approve or request modifications. Once validated, the agent finalizes the declaration, archives it in the client's folder with the firm's naming convention, and sends a confirmation notification. This process that previously took several hours is now executed automatically, with human supervision only at the validation moment.

Rather than a simple email send, this agent first checks the document management system to identify precisely which documents are missing for each file. It then analyzes the communication history with each client to adapt the message tone. A client who usually responds quickly receives a friendly reminder, while a client who tends to ignore initial follow-ups receives a more formal message with clear implications.

The agent personalizes each email with specific details of missing documents, attaches appropriate forms, and automatically schedules a follow-up if no response is received within a defined timeframe. This personalization creates a much more professional client experience than generic reminders.

At the end of each month, this agent automatically triggers for all clients who have subscribed to a monthly reporting service. It connects to Pennylane, extracts the month's data, generates trend analyses by comparing with previous months, creates interactive visualizations, compiles everything into a report formatted according to the firm's template, and sends it to the client with a personalized message.

The report includes not only raw numbers but also automatic insights on significant variations, potential anomalies, and key indicators. This level of reporting was previously offered only to the largest clients because it took too much time. Now, thanks to automation, all clients can benefit from it.

Creating an agent that works once is relatively easy. Creating an agent that functions reliably, day after day, under variable conditions, requires following certain best practices.

The temptation is often to want to immediately create the perfect agent that handles all possible cases and all imaginable variations. This approach generally leads to overly complex agents that are difficult to debug and maintain.

Instead, start with the simplest and most frequent use case. Create an agent that handles this basic scenario reliably. Once that works well, progressively add handling for additional cases. This iterative approach allows you to build complexity in a controlled manner and always maintain a functional agent.

Never assume a step went well simply because it does not generate an explicit error. Include checks after each important action to confirm the result is as expected.

If your agent is supposed to extract data from a file, verify that the file actually contains data and that it is in the expected format. If the agent creates a document, verify the document was indeed created and is not empty. These simple checks quickly detect problems before they propagate through the workflow.

Even the best-designed agent will occasionally encounter situations it cannot handle automatically. Rather than failing silently, configure your agent to notify you when it encounters a problem it cannot resolve alone.

These notifications should be informative, clearly explaining which step failed, why, and what human intervention is necessary. Over time, you will identify the most frequent exceptional situations and can improve your agent to handle them automatically.

As you create custom agents, document how they function. Explain which business process the agent automates, what the main workflow steps are, which tools it uses, and what the important considerations are.

This documentation is valuable for several reasons. It helps your colleagues understand what the agent does and when to use it. It facilitates future maintenance and modifications. And it serves as a reference when you create similar agents for other processes.

Custom agents are not static. Your business processes evolve, your tools change, your needs transform. A well-designed agent must be able to evolve easily.

Ubby facilitates modifying existing agents. You can add new steps to a workflow, modify triggers, update connectors, all while keeping the agent active and functional. Modifications can be tested in a separate environment before being deployed to production.

Regularly observe how your agents function in reality. Which steps fail most often? Where are execution times longer than expected? What types of human intervention are still necessary? These observations guide your continuous improvements.

You now have a solid understanding of how to create custom agents in Ubby. In the next article, we will explore how to manage and orchestrate multiple agents working together on complex processes, truly creating a coordinated digital workforce.