DEV Community: Miguel Ángel Cabrera Miñagorri

Giving agents a way to find other agents and tools

Miguel Ángel Cabrera Miñagorri — Thu, 18 Jun 2026 17:14:15 +0000

I've recently been thinking about how the agentic economy will evolve, and realized that we are still missing a very important step. How do some agents find others? How do those agents find the tools they need to complete their work?

So I built an experiment. I indexed all agents and tools that are public, tested them to check they are available, and ranked them based on how easy they are to use by other agents.

All of it is exposed via an MCP server and an A2A agent. You can choose any of the methods, connect it to your agent, and let it find others and complete more work than it can do alone.

If this is of interest, check it out and let me know what you think.

Find agents on tiza search

Stop prompting AI coding agents with screenshots!

Miguel Ángel Cabrera Miñagorri — Wed, 12 Nov 2025 19:49:07 +0000

Coding agents are awesome. You write your prompt and watch the magic happen. Many times, you can even skip the "watching" part and just do something else while the code updates.

However, there is still some friction on how you prompt the agent, especially when talking about UI/UX bugs.

I see people taking screenshots, drawing on them, then uploading those to the AI and writing a prompt along with it. It gets harder when you need to explain the user's behavior that led to an error. You have to take multiple screenshots, write down what happened, what you expected, sometimes you don't have time to take a screenshot if the UI changes fast, etc.
And after all that work, often the agent still doesn't understand the issue. It's just frustrating.

The good news is, it doesn't have to be like that! For years, we have had a way to explain and show bugs easily: screen recordings.

It's so easy to just record your screen, explain what's wrong, and send it to a colleague. Why for AI it's not the same?

At Nitpicks, we are tackling that friction. Without leaving your product page, click a button, record your screen showing a bug, and see the fix flow to your GitHub repository automatically on a pull request.

Give Nitpicks a try today

Writing AI prompts felt like writing essays

Miguel Ángel Cabrera Miñagorri — Sun, 10 Aug 2025 15:58:19 +0000

I’m a heavy user of AI coding tools, but for certain tasks — especially those involving visual changes — my prompts started getting absurdly long.

At first, I was explaining everything in text. Then I began attaching screenshots. Eventually, I even saw people editing images with arrows to explain what they meant.

One day, I thought: how could I just show the thing instead of describing it?

So I started experimenting with video. At first, it was just for fun — a way to respond to those “Hey, here is a nitpick” PM videos. I didn’t expect much.

But at some point, I figured out a way to make the AI understand these videos incredibly well, often better than it did with my carefully crafted text prompts with images.

That’s when I built a small tool — Nitpicks — that lets you record your screen (via a Chrome extension) while explaining a bug or an improvement or a new feature you want to implement, and automatically get a GitHub pull request addressing the code changes.

It’s been especially helpful in product teams where not everyone codes — people can just show what they mean, and the fix appears in a few minutes.

I’m still refining it, and I’d love to hear your thoughts.

Use Nitpicks at no cost

Strategies to monetize AI apps and agents

Miguel Ángel Cabrera Miñagorri — Mon, 24 Mar 2025 13:27:02 +0000

I am a developer who loves to build new stuff. I have built a huge amount of free and open-source apps and tools. For the past couple of years, I focused on building many AI tools and agents.

Traditional apps vs AI apps/agents monetization strategies

There is a fundamental difference between the traditional app and the new AI app and agents.

While the infrastructure costs for traditional applications are almost negligible - which means you can offer free tiers or even a free application - when we add AI, even a small number of users may break the bank due to the inference costs.

As developers, we are forced to add paywalls to the AI apps and agents so that we can, at least, cover the inference costs. There are two main approaches:

1. Credit system: selling users certain amounts of credits that are consumed as they use our app. This is the best alternative if you are building AI agents because you never know how much computation the user will actually spend.

2. Subscription: users pay a fixed amount every month. This is a high-risk implementation for the developer because the user consumption may be bigger than the subscription. With traditional applications, subscriptions could be of different tiers so that a user paying a "tier 1" had access to certain features while others paying a "tier 2" may have access to extra ones. The limitation with AI apps is different because you need to limit a feature the user is already paying for, which is not well received by the paying users.

There is a third approach that is becoming popular, despite the security issues implied for the users, which is asking for an AI provider API key. I highly discourage this method for two reasons: 1. Non-technical users have no idea what's an API key and they will mismanage it. 2. It goes against most providers' ToS.

Monetizing AI apps without paywalls

The ideal solution from the developer's point of view is that each user automatically pays his inference. Similar to how you plug appliances into the wall socket, you pay your electricity utility bill and connect whatever you want.
Also, developers want to monetize the apps, so allowing them to charge per run or adding a markup to the spending they could monetize from the first usage.

For users, this should happen automatically without having to pass a paywall per app and they should have total control and monitoring of how much they are spending and where their information is going.

The solution we built

We built BrainLink with the above in mind, to help fellow developers get more users and monetize their AI apps from the first usage.

Every user has a brain (an account) that can link to any application supporting BrainLink with a single click. The brain provides the application with identity, inference costs automatically covered by the user (using any of the 180+ supported models), and monetization (either adding a markup fee or a per-run price), among other features we are working on.

A user can access all the applications using just this brain, which significantly reduces the friction associated with signup forms and paywalls on individual apps.

I would love to get your feedback on BrainLink, so please feel free to comment or reach out!

BrainLink website

Stop asking users for their AI API keys

Miguel Ángel Cabrera Miñagorri — Wed, 12 Feb 2025 16:56:00 +0000

It is becoming a trend within the AI space to ask users to bring their own provider API key (OpenAI, Anthorpic, DeepSeek, etc.), especially among indie developers.

The main purpose is to avoid paying for the inference costs of the users, which are unpredictable and expensive.

However, asking users for their keys not only creates a ton of friction in your application, it also increases security risks and goes against most providers' policies.

To solve all these problems, I built BrainLink, which provides users with a global account that they can connect to your application with a single click.
After a user links their account with your application, you can obtain an access token to perform inference on behalf of the user, so that they pay exactly for what they consume within your application.

BrainLink also increases the flexibility of your code, since you are no longer tied to the user AI provider. You can use any model from any provider and even combine them for different features without needing multiple keys from your users.

I would love to help you integrate BrainLink if it is of your interest. It takes just 5 minutes. Feel free to write me at miguel@brainlink.dev

Integrate BrainLink in 5 minutes

Running AI locally in your users' browsers

Miguel Ángel Cabrera Miñagorri — Fri, 25 Oct 2024 11:00:02 +0000

We all know how great AI is, however, there are still two major problems: data privacy and cost.

All the applications using AI right now are connected to cloud APIs. These APIs log prompts and contexts and in some cases they use that data to train models. That means that any sensitive data you include on them is potentially exposed.

Most web applications integrate AI features using the following schema:

The problem here is that the application servers need to send the user data to the AI API, which is a third-party API and we cannot really know what will happen with the user data.

But, why don't we just process AI in the user device instead of the cloud? I have been testing it for a few weeks with amazing results. I found 3 main advantages:

The user data is never sent to a third-party. It always remains on the user device.
It's free for the app developer, you don't need to pay for the user inference, because it happens directly on the user device.
The scalability is unlimited as every single new user brings his own computation power.

Let's take a quick look at how the previous schema changes when we offload the AI computation to the users:

It's a very simple concept. The user uses the we application as always, but when there is some task that requires to perform AI computation, instead of using a third-party API, we send it to the user and it's device will perform that computation in the most secure way, locally.

This is not just a dream, it's already fully functional, and I created a platform called Offload so that everyone can use this architecture easily, just changing a few lines of code. The SDK will handle everything behind the scenes, from downloading a model that fits on the user device, to help you manage the prompts and evaluate prompt responses locally, sending back the evaluation results to you without exposing the user data. Everything works transparently with a single function invocation.

I am looking for web developers that may benefit from this, even if it is just for hobby projects, so, if you like this approach ping me! I would love to help you set it up in your application and you will see that it is actually really simple to migrate within minutes.

Integrate Offload in your application

Offload - A unified javascript SDK that enables in-browser AI

Miguel Ángel Cabrera Miñagorri — Tue, 08 Oct 2024 10:29:20 +0000

Today I want to share Offload, a javascript SDK to run AI directly on the users' browser.

What's Offload?

It is an SDK you can use to add AI to your website but with one peculiarity: it allows your users to run AI tasks locally, keeping their data on their devices, avoiding the need to send it to a third-party inference API.

Additionally, it decreases your costs and helps your application scale inexpensively. As more inference is offloaded to the users' devices, the fewer resources you need to allocate or spend on third-party APIs.

If you are an application developer, integrating Offload will only improve your application, as it will continue to work as usual while offering your users the ability to process their data locally, without any effort on your part.

Offload features

You can integrate Offload as a direct replacement of whatever SDK you are using right now, just changing your inference function calls.

Offload serves** models of different sizes to your users automatically**, depending on the device and its resources. If the user's device does not have enough resources, Offload will not show that user the option to process the data locally and will fall back to whatever API you specify via the dashboard.

In the dashboard, you can configure and manage the prompts, customize and test them for the different models, and get analytics from the users, and more. Everything without exposing your users' data to any third party, as everything is processed on-device.

Offload supports generating text responses, enforcing structured data objects via JSON schemas, streaming the text response, and more.

If there's anything else we do not support that you'd like to see, please leave a comment!

Why is Offload important?

I believe local AI is the future. However, as AI continues to advance, I am increasingly concerned about how our data is processed.

Every application that implements an AI feature today uses a remote API, where it sends the users' data. Most of these applications use public APIs such as OpenAI, Anthropic, and others. The flow is simple: the application collects the user data and sends it along with the prompt to the remote API, which replies with the generated text or image.

The big problem with this approach is that when you give an application access to a document, (or photo, video, or any piece of data), it sends your document to a remote API, which may include any sensitive information it contains. The remote API likely records the prompts, uses the data to train new models, or sells your data for other purposes.

I think the data privacy problem is even worse now that we have LLMs. LLMs allow indexing huge amounts of unstructured information in new ways that weren't possible before, and this increases the danger of exposing any personal piece of information.

For example, let's say you have a diary. It likely includes where you live, your schedules, who your friends are, where you work, maybe how much you earn, and much more. Even if not written directly, it can probably be inferred from the diary's content. Up until now, to infer that information, someone would need to read it entirely. However, with LLMs, one could gain enough data to impersonate you in seconds.

By using an app to chat with your diary, you are potentially exposing your information, as it is sent to some API.
On the other hand, if such an application uses Offload, you can use it securely since your data doesn't leave your device, and thus, it cannot be exposed.

This is especially important in industries that work with highly sensitive data, such as healthcare, legal, document processing apps, personal assistants, etc.

Integrate Offload in your application today!

Offloading AI inference to your users' devices

Miguel Ángel Cabrera Miñagorri — Thu, 12 Sep 2024 17:32:18 +0000

Integrating LLMs in existing web applications is becoming the norm. Also, there are more and more AI native companies. These create autonomous agents putting the LLM in the center and giving it tools allowing it to perform actions on different systems.

In this post I will present a new project called Offload, which allows you to move all that processing to the user devices, increasing their data privacy and reducing the inference costs.

The 2 problems

The are two big concerns when integrating AI in an application: Cost and user data privacy.

1. Cost. The typical way to connect an LLM is to use a third-party API, like OpenAI, Anthropic, or others, there are many alternatives in the market. These APIs are very practical, with just an HTTP request you can easily integrate an LLM into your application. However, these APIs are expensive at scale. They are putting big efforts into reducing the cost, but if you make many API calls per user per day the bill becomes huge.

2. User data privacy. Using third-party APIs for inference is not the best alternative if you work with sensitive user data. These APIs often use the data you send to continue training the model which can expose your confidential data. Also, the data could become visible at some level when it reaches the third-party API provider (for example in a logging system). This is not just a problem for companies, but also for consumers that may not want to send their data to those API providers.

Addressing them

Offload addresses both problems at once. The application "invokes" the LLM via an SDK that behind the scenes runs the model directly on each user device instead of calling a third-party API. This saves money on the inference bill because you do not need to pay for API usage and maintain the user data within each user device, not needing to send it to any API.

If this is of your interest and want to remain in the loop, check out the Offload website here

Automating your home with computer vision using any camera

Miguel Ángel Cabrera Miñagorri — Tue, 14 May 2024 07:51:54 +0000

We have more and more devices at home, these can perform several actions, but they need some intelligence to do that.

Home assistant allows us to automate tasks in our home by providing a hub where you can connect devices and give them instructions. It also allows some "if then, do that" logic, however, we felt like a more powerful brain was still missing.

During the last week, I created a small Pipeless Agents integration for Home Assistant, which allows you to automate your home using computer vision by connecting your existing cameras, no need to change them.

Until now, we could perform basic actions thanks to motion sensors and basic people recognition, but with this approach, we can allow our home to make its own decisions on what to do.

I created a tutorial so you can understand the basics. On it, you will learn how to connect Home Assistant with Pipeless Agents, set up a project, add your camera streams, and implement your custom logic and video filters.
We will deploy a simple example that turns off our TV when the people watching it leave the scene. You can continue playing around with that basic implementation and create more complex workflows and applications.

You don't need to know anything about computer vision since your code receives a structured data stream, you just need very basic Python knowledge.

The following is the complete step-by-step tutorial:

No-code Real-time Object Detection without training models

Miguel Ángel Cabrera Miñagorri — Thu, 02 May 2024 10:33:39 +0000

I am so happy to share this new feature of Pipeless Agents that allows you to export object detection models without training them. Just specify what you want to detect and your model will be ready in a few seconds!

Vision AI agents for any task

Miguel Ángel Cabrera Miñagorri — Tue, 30 Apr 2024 09:52:57 +0000

After spending some months working on the Pipeless open-source framework, today I bring something new and really cool: Pipeless Agents

Imagine providing a video source and directly processing a data stream that represents what is happening on the video, just like when you work with normal data. Each payload represents an event on the video, an object, or whatever you are interested in.

Sounds good, right? Well, it is now possible.

With Pipeless Agents you can create any kind of automation based on real-time video inputs. You do not need infrastructure, you do not need to label data or train models. You connect a git repository with your agent logic and the rest is handled for you.

So, what does that agent logic look like?

It is just a script that processes the data extracted from your video sources, like the following:

As you can see, with just two lines of code you can define the agent. The first imports the SDK and the second is a for loop that will run for every data structure extracted from the video. Inside the loop, you can do whatever you want. You can send emails or Slack notifications, you can call some webhooks, you can stop a production line, you can analyze and store the data in a database, ... There are no restrictions, the only limit is your imagination!

But, how does the agent know the kind of data/events you want?

We use some filters for that. Every filter focuses on exporting specific data or detecting a specific event. When you connect your video sources you also specify the list of filters that you want to apply to the video and every filter produces a well-defined data structure, which is what your agent receives.

Right now, we are providing some pre-defined filters such as object detection, but we are working to allow you to define your custom filters. Let us know if there is some specific filter you would like to see!

How do you get started?

Just go to https://agents.pipeless.ai and create your first agent!
Also don’t forget to send us your feedback, we love to hear your thoughts!

Hope you enjoy it!

Computer vision at the edge with Nvidia Jetson in 2 commands

Miguel Ángel Cabrera Miñagorri — Wed, 24 Jan 2024 10:10:44 +0000

A few days ago I explained the benefits of using the Pipeless computer vision framework to develop and deploy your applications. Among other advantages, you get multi-stream processing and dynamic configuration out-of-the-box. This means you can add, edit and remove streams on the fly, without restarting your program, as well as specify how those streams should be processed at the time of adding the stream.
In this post I will guide you through the list of commands that you need to deploy a Pipeless application to a Nvidia Jetson device. This example has been tested on a Nvidia Jetson Xavier, but it should work with other models too.

Walkthrough

First, install Pipeless on the Jetson device. Connect to the device via ssh and run the following command. Note iT will show some env vars at the end that you need to export:

curl https://raw.githubusercontent.com/pipeless-ai/pipeless/main/install.sh | bash

Then, the only other piece we need is to add our Pipeless stages. In this case, we will use the YOLOv8 example. You can learn more about Pipeless stages here, but in short, a stage is like a micro-pipeline. You can plug several stages one after the other dynamically when providing streams to Pipeless, so you can modify the processing behaviour per stream without changing your code and without restarting your application.

Let’s install some dependencies:

pip install opencv-python numpy ultralytics

Create the new project folder and download the YOLOv8 stage functions:

pipeless init my-project --template empty # Using the empty template we avoid the interactive shell
cd my-project
wget -O - https://github.com/pipeless-ai/pipeless/archive/main.tar.gz | tar -xz --strip=2 "pipeless-main/examples/yolo"

You can now start Pipeless:

pipeless start --stages-dir .

And provide a stream as follows:

pipeless add stream --input-uri "https://pipeless-public.s3.eu-west-3.amazonaws.com/cats.mp4" --output-uri "screen" --frame-path "yolo"

The above command assumes you have a display connected to the Jetson device to visualize the output stream. If you don’t have a display connected you can change the output URI to use a file or some multimedia server you may have.

And that’s all! Impressive, right?

You can find more examples in our documentation and learn how to create applications from scratch using Pipeless.

If you like the ease of creating and deploying computer vision applications with Pipeless don’t forget to star our GitHub repository.

pipeless-ai / pipeless

An open-source computer vision framework to build and deploy apps in minutes

Pipeless

Easily create, deploy and run computer vision applications.

Pipeless is an open-source framework that takes care of everything you need to develop and deploy computer vision applications in just minutes. That includes code parallelization, multimedia pipelines, memory management, model inference, multi-stream management, and more. Pipeless allows you to ship applications that work in real-time in minutes instead of weeks/months.

Pipeless is inspired by modern serverless technologies. You provide some functions and Pipeless takes care of executing them for new video frames and everything involved.

With Pipeless you create self-contained boxes that we call "stages". Each stage is a micro pipeline that performs a specific task. Then, you can combine stages dynamically per stream, allowing you to process each stream with a different pipeline without changing your code and without restarting the program. To create a stage you simply provide a pre-process function, a model and a post-process function.

…

View on GitHub