DEV Community: Miguel Ángel Cabrera Miñagorri

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

Creating a computer vision app in minutes with just two Python functions

Miguel Ángel Cabrera Miñagorri — Tue, 02 Jan 2024 12:10:23 +0000

This article starts with an overview of what a typical computer vision application requires. Then, it introduces Pipeless, an open-source framework that offers a serverless development experience for embedded computer vision. Finally, you will find a detailed step-by-step guide on the creation and execution of a simple object detection app with just a couple of Python functions and a model.

Introduction - Inside a Computer Vision Application

The art of identifying visual events via a camera interface and reacting to them

That is what I would answer if someone asked me to describe what computer vision is in one sentence. But it is probably not what you want to hear. So let's dive into how computer vision applications are typically structured and what is required in each subsystem.

Really fast frame processing: Note that to process a stream of 60 FPS in real-time, you only have 16 ms to process each frame. This is achieved, in part, via multi-threading and multi-processing. In many cases, you want to start processing a frame even before the previous one has finished.
An AI model to run inference on each frame and perform object detection, segmentation, pose estimation, etc: Luckily, there are more and more open-source models that perform pretty well, so we don't have to create our own from scratch, you usually just fine-tune the parameters of a model to match your use case (we will not deep dive into this today).
An inference runtime: The inference runtime takes care of loading the model and running it efficiently on the different available devices (GPUs or CPUs).
A GPU: To run the inference using the model fast enough, we require a GPU. This happens because GPUs can handle orders of magnitude more parallel operations than a CPU, and a model at the lowest level is just a huge bunch of mathematical operations. You will need to deal with the memory where the frames are located. They can be at the GPU memory or at the CPU memory (RAM) and copying frames between those is a very heavy operation due to the frame sizes that will make your processing slow.
Multimedia pipelines: These are the pieces that allow you to take streams from sources, split them into frames, provide them as input to the models, and, sometimes, make modifications and rebuild the stream to forward it.
Stream management: You may want to make the application resistant to interruptions in the stream, re-connections, adding and removing streams dynamically, processing several of them at the same time, etc.

All those systems need to be created or incorporated into your project and thus, it is code that you need to maintain. The problem is that you end up maintaining a huge amount of code that is not specific to your application, but subsystems around the actual case-specific code.

The Pipeless Framework

To avoid having to build all the above from scratch, you can use Pipeless. It is an open-source framework for computer vision that allows you to provide a few functions specific to your case and it takes care of everything else.

Pipeless splits the application's logic into "stages," where a stage is like a micro app for a single model. A stage can include pre-processing, running inference with the pre-processed input, and post-processing the model output to take any action. Then, you can chain as many stages as you want to compose the full application even with several models.

To provide the logic of each stage, you simply add a code function that is very specific to your application, and Pipeless takes care of calling it when required. This is why you can think about Pipeless as a framework that provides a serverless-like development experience for embedded computer vision. You provide a few functions and you don't have to worry about all the surrounding systems that are required.

Another great feature of Pipeless is that you can add, remove, and update streams dynamically via a CLI or a REST API to fully automate your workflows. You can even specify restart policies that indicate when the processing of a stream should be restarted, whether it should be restarted after an error, etc.

Finally, to deploy Pipeless you just need to install it and run it along with your code functions on any device, whether it is in a cloud VM or containerized mode, or directly within an edge device like a Nvidia Jetson, a Raspberry, or any others.

Creating an Object Detection Application

Let's deep dive into how to create a simple application for object detection using Pipeless.

The first thing we have to do is to install it. Thanks to the installation script, it is very simple:

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

Now, we have to create a project. A Pipeless project is a directory that contains stages. Every stage is under a sub-directory, and inside each sub-directory, we create the files containing hooks (our specific code functions). The name that we provide to each stage folder is the stage name that we have to indicate to Pipeless later when we want to run that stage for a stream.

pipeless init my-project --template empty
cd my-project

Here, the empty template tells the CLI to just create the directory, if you do not provide any template, the CLI will prompt you several questions to create the stage interactively.

As mentioned above, we now need to add a stage to our project. Let's download an example stage from GitHub with the following command:

wget -O - https://github.com/pipeless-ai/pipeless/archive/main.tar.gz |
          tar -xz --strip=2 "pipeless-main/examples/onnx-yolo"

That will create a stage directory, onnx-yolo, that contains our application functions.

Let's check the content of each of the stage files; i.e., our application hooks.

We have the pre-process.py file, which defines a function (hook) taking a frame and a context. The function makes some operations to prepare the input data from the received RGB frame in order to match the format that the model expects. That data is added to the frame_data['inference_input'] which is what Pipeless will pass to the model.

def hook(frame_data, context):
    frame = frame_data["original"].view()
    yolo_input_shape = (640, 640, 3) # h,w,c
    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    frame = resize_rgb_frame(frame, yolo_input_shape)
    frame = cv2.normalize(frame, None, 0.0, 1.0, cv2.NORM_MINMAX)
    frame = np.transpose(frame, axes=(2,0,1)) # Convert to c,h,w
    inference_inputs = frame.astype("float32")
    frame_data['inference_input'] = inference_inputs

... (some other auxiliar functions that we call from the hook function)

We also have the process.json file, which indicates Pipeless the inference runtime to use (in this case, the ONNX Runtime), where to find the model that it should load, and some optional parameters for it, such as the execution_provider to use, i.e., CPU, CUDA, TensortRT, etc.

{
    "runtime": "onnx",
    "model_uri": "https://pipeless-public.s3.eu-west-3.amazonaws.com/yolov8n.onnx",
    "inference_params": {
        "execution_provider": "tensorrt"
    }
}

Finally, the post-process.py file defines a function similar to the one at pre-process.py. This time, it takes the inference output that Pipeless stored at frame_data["inference_output"] and performs the operations to parse that output into bounding boxes. Later, it draws the bounding boxes over the frame, to finally assign the modified frame to frame_data['modified']. With that, Pipeless will forward the stream that we provide but with the modified frames including the bounding boxes.

def hook(frame_data, _):
    frame = frame_data['original']
    model_output = frame_data['inference_output']
    yolo_input_shape = (640, 640, 3) # h,w,c
    boxes, scores, class_ids =
           parse_yolo_output(model_output, frame.shape, yolo_input_shape)
    class_labels = [yolo_classes[id] for id in class_ids]
    for i in range(len(boxes)):
        draw_bbox(frame, boxes[i], class_labels[i], scores[i])

    frame_data['modified'] = frame

... (some other auxiliar functions that we call from the hook function)

The final step is to start Pipeless and provide a stream. To start Pipeless, simply run the following command from the my-project directory:

pipeless start --stages-dir .

Once running, let's provide a stream from the webcam (v4l2) and show the output directly on the screen. Note we have to provide the list of stages that the stream should execute in order; in our case, it is just the onnx-yolo stage:

pipeless add stream --input-uri "v4l2" --output-uri "screen" --frame-path "onnx-yolo"

And that's all!

Conclusion

We have described how creating a computer vision application is a complex task due to many factors and the subsystems that we have to implement around it. With a framework like Pipeless, getting up and running takes just a few minutes and you can focus just on writing the code for your specific use case. Furthermore, Pipeless' stages are highly reusable and easy to maintain so the maintenance will be easy and you will be able to iterate very fast.

If you want to get involved with Pipeless and contribute to its development, you can do so through its GitHub repository, don't forget to add your star!.

pipeless-ai / pipeless

An open-source computer vision framework to build and deploy apps in minutes without worrying about multimedia pipelines

Pipeless

Easily create, deploy and run computer vision applications.

Check the live demo in the website

Pipeless is an open-source computer vision framework to create and deploy applications without the complexity of building and maintaining multimedia pipelines. It ships everything you need to create and deploy efficient computer vision applications that work in real-time in just minutes.

Pipeless is inspired by modern serverless technologies. It provides the development experience of serverless frameworks applied to computer vision. You provide some functions that are executed for new video frames and Pipeless takes care of everything else.

You can easily use industry-standard models, such as YOLO, or load your custom model in one of the supported inference runtimes. Pipeless ships some of the most popular inference runtimes, such as the ONNX Runtime, allowing you to run inference with high performance on CPU or GPU out-of-the-box.

You can deploy your Pipeless application to edge…

View on GitHub