<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Joao Silva on Medium]]></title>
        <description><![CDATA[Stories by Joao Silva on Medium]]></description>
        <link>https://medium.com/@joaolealdasilva?source=rss-58a4c1491c11------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*PdRp62eKFiTxoGNMzlm9UQ@2x.jpeg</url>
            <title>Stories by Joao Silva on Medium</title>
            <link>https://medium.com/@joaolealdasilva?source=rss-58a4c1491c11------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 05:07:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@joaolealdasilva/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[32 Portuguese channels, one Docker stack]]></title>
            <link>https://joaolealdasilva.medium.com/32-portuguese-channels-one-docker-stack-f917a9413c8a?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/f917a9413c8a</guid>
            <category><![CDATA[self-hosted]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[streaming]]></category>
            <category><![CDATA[portugal]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 21:09:44 GMT</pubDate>
            <atom:updated>2026-11-09T21:27:02.552Z</atom:updated>
            <content:encoded><![CDATA[<p><em>PT TV Tuner is a small MIT stack that plays live Portuguese television and radio in the browser. I built it to keep up with the news and culture from home without the hassle, and because JavaScript cannot set the Referer a broadcaster wants.</em></p><p>I am Portuguese, and I live in the UK. What I want from Portuguese television is not a project. It is the news, a bit of culture, and a radio station on in the background, without turning it into a small IT exercise every time. That is the whole motivation behind PT TV Tuner: keep up with the news and culture from home, with as little friction as possible.</p><p>The channels are still there, the websites still list them, and the streams still leave the building. What breaks is everything between the broadcast tower and the browser tab: a page that wants to know where you are, a player that expects headers your browser will not send, and a channel list that changes every few months without telling anyone.</p><p>I built PT TV Tuner to sit in that gap. It is a Docker stack with three small services, a catalogue of thirty-two channels, and a player that looks like something you would choose to use on a television rather than something that arrived with a router. The repository is <a href="https://github.com/ciberjohn/pt-tv-tuner">public and MIT-licensed</a>, the landing page is at <a href="https://tvpt.lealdasilva.com/">tvpt.lealdasilva.com</a>, and the first working version was seven commits across sixty-one minutes.</p><p>The commit count says more about the size of the thing than about my speed. Most of the work was not the interface. It was accepting that the browser is the wrong place to make these requests, and putting a small server in front of it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RQcFjVFSlYe6Wl5G41q6Uw.png" /><figcaption><em>This image was created using an AI image creation program.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jpqWNq1lWG7UMZxzPb2yQw.png" /><figcaption>PT TV Tuner home screen: a dark channel rail on the left with twelve television channels and twenty radio stations, and an empty player on the right with the prompt “Escolha um canal para começar”</figcaption></figure><h3>What it is</h3><p>Three containers. The first serves a React build through an unprivileged nginx. The second is the proxy, a zero-dependency Node service that speaks to the broadcasters. The third serves the landing page: a static page with two screenshots and a quickstart, because a project like this needs a front door that isn&#39;t a README.</p><p>The app listens on port 8090, the landing page on 8091, and both bind to loopback by default. The loopback binding matters more than it looks. A stream proxy is an open door to whatever its allowlist permits, and the safest default for a personal tuner is a door only the host can see, with a tunnel or a reverse proxy in front when you want it from the sofa. The compose file even pins its bridge to a fixed private subnet so a tailnet route can never shadow it.</p><p>The catalogue is thirty-two entries: twelve television channels and twenty radio stations. RTP 1, RTP Notícias, RTP Açores, RTP Madeira, RTP Mundo, TVI, CNN Portugal, RTP 2, RTP Memória, RTP África, SIC and SIC Notícias on the television side. Antena 1, 2 and 3, the Açores and Madeira Antena stations, RTP Mundo Rádio, RTP África Rádio, Lusitânia, Fado, Jazzin, Ópera, Zig Zag and RTP Vida, then Rádio Comercial, M80, Smooth FM, Cidade FM, Rádio Observador and TSF on the radio side.</p><p>Twenty-six of those are marked as world channels. Six carry a small PT badge and a warning: they expect a Portuguese connection.</p><h3>The header nobody can set</h3><p>Several broadcasters check the Referer and User-Agent headers before they will hand over a playlist. A browser will not let JavaScript set either one on a cross-origin request. Referer is a forbidden header name: the browser derives it from the page you are on, and fetch will quietly ignore your attempt to change it. You can set a custom User-Agent in some contexts, but not in a page, and not in a way the other end will trust.</p><p>The second half of the problem is CORS. Many of these HLS endpoints return no Access-Control-Allow-Origin header at all, so even when the URL is reachable, the browser refuses to let the page read the response.</p><p>So the browser cannot make the request correctly, and even if it could, it could not read the answer. That is not a bug to work around with a clever fetch. It is a boundary, and the only honest way past it is a server that makes the request on the page’s behalf.</p><p>The proxy does exactly that, and nothing else. It looks up the channel by ID, fetches the upstream playlist with a browser-like User-Agent, the RTP Play Referer the code defaults to, and Accept-Language: pt-PT, then rewrites every child URI in the playlist so it points back through the same service. Segments stream through it unchanged. The page only ever talks to its own origin, which means no CORS negotiation, no forbidden headers and no broadcaster URL in the markup.</p><p>The URLs are carried as base64url tokens, which keeps them out of the page rather than secret. Anyone who wants the real endpoint can decode one. The point is that the player does not need to know it.</p><h3>A channel list is data, not code</h3><p>Stream URLs rot. A broadcaster changes a path, adds a session token, moves a redirect, and a player with the URLs compiled into it needs a new build for something that should be a five-line edit.</p><p>PT TV Tuner keeps the catalogue in data/channels.json, mounted into the proxy container. Each entry is an ID, a name, a type, a group, a region and a source. Adding a station means adding an object and restarting the proxy. The frontend fetches the same catalogue from /channels at load, so the rail and the proxy never disagree about what exists.</p><p>That design ran into a real bug during the build, and the fix is the sort of detail that only shows up when you test against more than one broadcaster. One upstream serves its playlist with a session token in the query string. Its child URLs are relative, so resolving them against the playlist should be enough. Except a relative URL has no query string of its own, which means the token disappears on the first segment request and the CDN answers 403. The proxy now carries the parent’s query forward when the child has none, for the same host only. That single change is the difference between a channel that works and a channel that looks broken.</p><h3>The switch that tells the truth</h3><p>Geo-blocking is the part of this project that could most easily become dishonest. A player that shows a channel, spins, and says nothing is worse than one that explains the constraint.</p><p>The PT switch shows or hides the six channels that require a Portuguese connection, and each wears a PT badge so the warning is visible before you click. The switch reveals, not bypasses. Turning it on doesn&#39;t give you a Portuguese address. What decides playback is where the proxy’s host sits, and the interface says so in Portuguese when the upstream refuses:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*owOE5220VbT4IYrIk423PA.gif" /><figcaption>turning the PT-only switch off and on, with the six badged channels disappearing from the rail and returning</figcaption></figure><blockquote><em>Este canal requer uma ligação portuguesa (VPN/relay PT). Indisponível fora de Portugal.</em></blockquote><p>From a UK connection, SIC and SIC Notícias return a 502 upstream error, and that message appears. The pt badge is a warning rather than a guarantee, and the difference is worth stating plainly: RTP 2 carries the badge and played from the same connection while I was testing. The catalogue marks channels likely to need Portuguese egress, and the player reports what actually happened instead of pretending the badge is a law.</p><p>This is also the part where the legal note belongs, early rather than buried. PT TV Tuner <strong>hosts no media and stores no media</strong>. It streams from publicly reachable endpoints with the requests those endpoints expect. The content remains the broadcasters’, and their terms apply. Use it for personal viewing. Do not run it as a public relay, and do not use it to bypass restrictions you are not entitled to bypass.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VOwUnXallLcp3NJXjcxEWA.png" /><figcaption>SIC selected from a UK connection, with the player’s Portuguese explanation that the channel requires a Portuguese connection</figcaption></figure><h3>What it looks like when it runs</h3><p>The idle screen is a channel rail and a prompt. Click a channel and the player takes over the right-hand side, with the station name underneath and a red Parar button in the top corner.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*EBJd5-vTle2NBLsPHNCAyw.gif" /><figcaption>the idle screen, the pointer moving to RTP 1, the tuning message, and the live broadcast starting</figcaption></figure><p>Stopping is a button, not a page reload. Parar, or the Escape key, tears down the HLS instance, clears the video source and puts the channel choice back on screen. That sounds like a small thing. It is the difference between a player and a page that happens to contain a video.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*L8rSE-t9Fs6H4aIPGKRUoQ.gif" /><figcaption>pressing Parar during a live broadcast and returning to the channel chooser</figcaption></figure><p>Fullscreen is the browser’s own control, which is deliberate. A custom overlay would have to be rebuilt for every platform and would still lose to the browser on iOS. The native control behaves the way people already expect.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*RyZ2q8KPWpLlFolSmuVLZw.gif" /><figcaption>taking the live player fullscreen and coming back to the page</figcaption></figure><p>Radio uses the same player, with one change. The video element stays for the audio stream, and an animated seven-bar panel covers it with the station name and the words em direto. It is a small piece of CSS that keeps a radio station from looking like a television channel with the picture turned off.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nCRL5YFzS2aO3uuUUzg4KA.png" /><figcaption>Antena 1 playing with the animated radio panel</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BAUOVurmaoA_1d5HF-iAfw.png" /><figcaption>the lower half of the channel rail, showing the commercial radio stations down to TSF</figcaption></figure><p>On a phone, the rail moves to the bottom as a horizontal strip of logos and the player takes the top of the screen. The Parar button stays where your thumb can find it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*h0hyoEEEYwyP92Bcwee-Jw.png" /><figcaption>the mobile layout: player at the top, channel rail along the bottom</figcaption></figure><h3>Hardening a player that faces the internet</h3><p>A stream proxy is a service that fetches URLs listed in a catalogue file, and one bad entry away from becoming a request forwarder for anything on the network. The proxy treats that as its main risk.</p><p>It only speaks HTTPS, only to hosts on an allowlist, and only on port 443. It refuses private, loopback, link-local and CGNAT addresses by parsing the hostname as an IP before any request is made. Redirects are followed manually, at most three, with the scheme, host and port re-validated on every hop, because a redirect is the obvious way to walk an allowlist out of bounds. Playlists are capped at 4 MB, segments at 64 MB, and upstream requests time out after fifteen seconds.</p><p>The web tier adds the rest. Requests are rate-limited per address at 30 per second, with a burst of 60 on the stream routes and 120 on segments, and connections are capped per address. The response carries a content security policy that allows scripts only from its own origin and the hls.js worker from a blob. The proxy and web containers run read-only, with all Linux capabilities dropped, no-new-privileges set and memory and PID limits in the compose file. The proxy image has no dependencies, so there is no package tree to audit.</p><p>None of that makes it a hardened public service, and the loopback default is the honest acknowledgement. It makes one personal tuner considerably less interesting to anyone who finds it.</p><h3>Running it</h3><p>You need Docker with the Compose plugin and nothing else.</p><pre>git clone https://github.com/ciberjohn/pt-tv-tuner.git<br>cd pt-tv-tuner<br>docker compose up -d --build</pre><p>Open http://localhost:8090. Change the port with WEB_PORT=9090 docker compose up -d. Edit data/channels.json and restart the proxy to change the lineup. The README lists the main configuration variables and their defaults, including ALLOW_HOSTS for the proxy&#39;s allowlist.</p><p>The measured startup, on my own host through a tunnel and a headless browser, averaged 3.3 seconds from click to playing across six loads of RTP 1, RTP Notícias, and CNN Portugal. The fastest was 1.5 seconds, and a cold CNN Portugal load took 12.4 seconds, which I have not chased. None of that is a benchmark. It is enough to know the thing is usable.</p><h3>What I am thinking of changing next</h3><p>The list is longer than the feature list.</p><p>There is no programme guide, no favourites and no search. For thirty-two channels, a search box is optional, and a favourites row is not; I use four or five stations, and they should be at the top without me scrolling past the ones I don&#39;t.</p><p>The catalogue is still edited by hand. The plan had a refresh script that would pull from public playlist projects, flag dead sources and rewrite the file. It is not in the repository yet, and until it is, I find a rotten URL by clicking.</p><p>There are no tests. For a stack this size, the valuable ones are narrow: does every catalogue entry have a valid type and region, does the playlist rewriter produce the same number of segment lines it consumed, does the allowlist reject a host that merely ends with an allowed domain. None of those needs a browser.</p><p>The interface copy is Portuguese, and the README is English, which is right for the product and slightly awkward for anyone reading the repository first.</p><p>And the honest structural answer: a channel list is a maintenance contract. Every source in it belongs to somebody else and can change without notice. The design keeps that cost to a file edit, which is the best a project like this can do, but it does not make the cost zero.</p><h3>In the end</h3><p>The interesting part of this build was not the player. It was finding the line where the browser stops being able to help and a server has to take over. Once that line was clear, the rest was a channel list, a switch and a stop button.</p><p>If you have ever tried to watch a Portuguese channel from outside Portugal and ended up in a tab that spins, the reason is usually one of the two constraints above, and neither is a mystery. It is just a boundary. Put a small service on the other side of it, keep the catalogue in a file, and tell the user the truth when a channel will not play.</p><p><em>PT TV Tuner is MIT licensed. The source, the catalogue and the quickstart are at </em><a href="https://github.com/ciberjohn/pt-tv-tuner"><em>github.com/ciberjohn/pt-tv-tuner</em></a><em>.</em></p><h3>Sources</h3><ul><li><a href="https://github.com/ciberjohn/pt-tv-tuner">github.com/ciberjohn/pt-tv-tuner</a> — the repository: React frontend, Node HLS proxy, nginx configuration, compose file and channel catalogue.</li><li><a href="https://tvpt.lealdasilva.com/">tvpt.lealdasilva.com</a> — the landing page and quickstart.</li><li><a href="https://github.com/video-dev/hls.js">hls.js</a> — the HLS player used everywhere except Safari and iOS.</li><li><a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referer">MDN: Referer header</a> — why a page cannot set it freely.</li><li><a href="https://developer.mozilla.org/en-US/docs/Web/API/Fullscreen_API">MDN: Fullscreen API</a> — the native control behind the fullscreen frame.</li><li><a href="https://docs.docker.com/compose/">Docker Compose documentation</a> — the packaging and the docker compose up workflow.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f917a9413c8a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Deploy a Private SaaS on Coolify, Using a Job App for a Plasterboard Builder]]></title>
            <link>https://joaolealdasilva.medium.com/how-to-deploy-a-private-saas-on-coolify-using-a-job-app-for-a-plasterboard-builder-165c4cb4a851?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/165c4cb4a851</guid>
            <category><![CDATA[small-business]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[coolify]]></category>
            <category><![CDATA[self-hosted]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 15:06:01 GMT</pubDate>
            <atom:updated>2026-10-28T15:06:01.773Z</atom:updated>
            <content:encoded><![CDATA[<p>A self-employed plasterboarder does not need a platform. He needs to know how many boards to order, what to charge, and which job is next. He pays for everything else in evenings as overhead.</p><p>So I built him a small one anyway, because the shape is the point. A private repository, a database, a deploy button, and a server he can point at from a phone on site. That is what Coolify sells itself as, and I wanted to know whether a one-man trade could actually run on it without hiring anyone to keep it alive.</p><p>The builder is invented. The app is not. It is running as I write this, deployed through Coolify from a private GitHub repository, with a PostgreSQL database that Coolify provisioned and wired up on its own.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ggn09IGAE--icBZwKs4_Bw.png" /></figure><h3>What Coolify actually is</h3><p>Coolify is an open-source, self-hostable alternative to Vercel, Heroku and Netlify. The repository carries an Apache-2.0 licence, and at the time of writing it has around 65,000 stars and 5,800 forks, enough of a crowd that people find problems quickly.</p><p>It runs as a set of Docker containers on a machine you own. You give it a Git repository or a Docker image; it builds it and starts the result behind Traefik, its own reverse proxy. The list of one-click services runs to several hundred, which matters to anyone who doesn&#39;t want to learn Postgres administration on a Tuesday night.</p><p>The version under test is v4.5.0, released on 23 October 2026, installed on 26 October.</p><h3>The box</h3><p>I gave it a container with four cores, six gigabytes of memory and sixty gigabytes of disk. That is more than a builder needs and less than a small agency would want. The installer took one minute and fifty-six seconds from start to finish and left five containers running: the dashboard, its own Postgres, Redis, a sentinel process for housekeeping, and the proxy.</p><p>Two ports matter, and one of them surprised me. The dashboard listens on 8000. The real-time service, which keeps the interface live, listens on 6001. If you put anything in front of Coolify and forget 6001, the interface loads and then sits under a permanent “cannot connect to real-time service” banner. It looks broken. It is not, you just cut a hole in it.</p><p>The proxy takes 80 and 443 on the host. That is deliberate, and it is why the first thing to understand about Coolify is that it is not a guest on your server. It is the front door.</p><h3>First login</h3><p>The first account is created at /register, and the password needs a symbol, which the form does not tell you until you try. Then a short setup wizard asks where you are deploying; since this is a single box, choose &quot;This machine&quot;. Coolify validates Docker, creates a project and a production environment, and drops you on a dashboard with nothing in it.</p><p>I made one project, Plasterboard Jobs, and left the default project sitting there, looking embarrassed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*7xVM5KrtXbu9P9zPzZ6xnw.gif" /><figcaption>moving from the dashboard to the project, its environment and the deployment history</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ePSIiKNNhfTyf-hufnS2Pg.png" /><figcaption>the Coolify dashboard after setup, with the project and its localhost server</figcaption></figure><h3>The database first</h3><p>Order matters more than it looks. The app needs a connection string to start, so the database comes first.</p><p>From inside the project, you add a resource and pick a database. Coolify’s interface offers Postgres 18 by default, with 17, 16, Supabase’s build, PostGIS, and the vector variants beside it. The resource I ended up with runspostgres:16-alpine, which is what Coolify provisions when you do not specify an image. It asked for a name and whether to deploy immediately, and that was the whole form. Sixteen has been fine for this workload, though if I were starting again I would pick 18 and stay on a supported major for longer.</p><p>A few seconds later, there is a running Postgres, a generated password, and an internal connection string in the form postgres://user:pass@container-name:5432/postgres. That hostname is a Docker container name on the shared network, not a public address. Nothing needs to be exposed, and nothing should be.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P3Opr5m2hhvxQQGkktB5lA.png" /><figcaption>the managed PostgreSQL resource, with the password and connection string masked</figcaption></figure><h3>The private repository and the GitHub App</h3><p>Here is where a self-hosted platform earns its keep, and where the afternoon went.</p><p>The app lives in a private repository. That means Coolify needs credentials to clone it, and you can provide them in three ways: a deploy key, a personal access token, or a GitHub App. The App is the right one for anything you intend to keep. It is scoped to the repositories you choose, can be revoked without touching your account, and enables automatic deploys later.</p><p>The flow is: open Integrations, add a GitHub App, and press Create. Coolify then sends you to GitHub with a manifest, GitHub creates the app, and redirects you back with a code that Coolify exchanges for the credentials.</p><p>Mine did not come back.</p><p>The redirect went to http://&lt;my-public-ip&gt;:8000/webhooks/source/github/redirect?code=…, which is an address on the open internet where nothing is listening, because the whole point of this box is that it is not published. The browser said the site could not be reached, and the app sat half-created on GitHub with no credentials on the Coolify side.</p><p>The cause is a field called fqdn in the instance settings. On a fresh install, it is empty, so Coolify builds every callback URL from the public IPv4 it detects for the machine. On a normal cloud server with a real domain, that is fine. On a box behind a CGNAT router, that address only exists from the outside, and only in theory.</p><p>Setting the instance address to the host you actually use, then restarting the dashboard, fixes it. Retry the flow and the redirect lands where it should.</p><p>It is worth saying plainly that this is a configuration trap rather than a defect. The installer cannot know what address you will reach it on. But if you don&#39;t know the field exists, it costs an hour, and the error message is the browser’s, not Coolify’s, so nothing points to the cause.</p><p>Once the redirect worked, the installation page asked which repositories to grant access to. One repository, plasterboard-jobs, and nothing else. A GitHub App that can read every repo you own is a worse idea than it looks, because the blast radius of a stolen key is everything you have ever written.</p><h3>The deploy</h3><p>With the app registered, you create an application resource, point it at the repository and the branch, and tell Coolify how to build it. Mine uses the Dockerfile in the repository root, which is the least magical option: Node 22, an install, a copy, a health check.</p><p>Two settings matter for this setup.</p><p>The first is the exposed port, 3000. The second is the port mapping, 3000:3000, which publishes the container directly on the host. That is the alternative to giving the app a domain and letting Traefik route to it. For a demo on a private network, port mapping is simpler and keeps the proxy out of the way.</p><p>Press deploy, and the log tells you the truth about your Dockerfile, line by line.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*NQ41n9NMw-ZQtX66Hx1bew.gif" /><figcaption>the deployment log filling as the image builds and the container starts</figcaption></figure><p>The build took thirty-six seconds. Then Coolify created the container, attached it to the shared network, injected the environment variables, and started it. The status went to running, the health check went green, and the app answered on port 3000 with the seven seeded jobs I had put in the repository for exactly this purpose.</p><p>That is the whole promise of the product, executed: a private repository became a running service without a single SSH session to the runtime.</p><h3>The app it produced</h3><p>The app is deliberately unglamorous. A builder does not want a dashboard; he wants an answer.</p><p>The overview shows open quotes by value, jobs on site by area, and invoices waiting to be paid. Behind it there is a job list, a customer list, and a quote form that does the only clever thing in the product.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q_V3gN832r1dfJRwAkl9Vw.png" /><figcaption>the job manager’s overview, showing live jobs and quotes outstanding</figcaption></figure><p>You measure the room, enter the area in square metres, pick the board, and it calculates the rest. Boards at 2.4 by 1.2 metres, with a ten per cent cut allowance; screws at thirty-two per board; scrim tape, jointing compound, and adhesive. Labour at a day rate, with a coverage rate of 26 square metres boarded and fixed per day. It adds it up, shows the lines, and gives a total.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ix3cjIn4wqOFHR6qweih2A.png" /><figcaption>a job’s material take-off, with boards, fixings and labour priced</figcaption></figure><p>A plasterer does that sum in his head and gets it wrong at nine at night. Doing it in a form is not a technical achievement; it is a small mercy.</p><p>Creating a quote is one screen: six fields, a select, an area, and a date.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*_mOJ_8wsXmxy3X_yQILwCg.gif" /><figcaption>creating a quote, from the form to the finished job record</figcaption></figure><p>And because work moves, the status does too: quoted, booked, in progress, complete, invoiced, paid, with a timestamped history behind each change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*aplN15vmVgW5uwqzLS1BOQ.gif" /><figcaption>moving a job from in progress to complete, with the timeline updating</figcaption></figure><p>[</p><h3>What broke, and what I did about it</h3><p>Two things went wrong that are worth recording, because a piece that only shows the happy path is an advert.</p><p>The first is the redirect problem above, which is a configuration trap and is fixable in one setting.</p><p>The second is a genuine defect in v4.5.0. On the page where you pick a database image, the browser console throws an uncaught error: searchResources is not defined. It doesn&#39;t stop you from creating the database, and I built the whole demo around it, but it is an uncaught exception in a shipped release, which means something on that page is wired to a function that doesn&#39;t exist. The API tokens page has a sibling problem, totalPages is not defined.</p><p>I reported it upstream rather than only complaining here: <a href="https://github.com/coollabsio/coolify/issues/12337">coollabsio/coolify#12337</a>. There is already a merged fix for the same class of bug in a neighbouring component, so this is maintenance debt on a fast-moving project rather than rot.</p><p>The honest version is that the faults I hit were in the plumbing around deployment, not in the deployment itself. The build, the database, the environment variables and the restart all did what they said.</p><h3>The thing it cannot do on a private network</h3><p>One limitation belongs in the piece because it changes how you would run this.</p><p>Coolify’s best feature is that a push to the default branch triggers a deploy. That needs GitHub to reach your instance over the public internet to deliver a webhook. My instance lives on a private network, so GitHub cannot call it, and you have to start deploys from the button.</p><p>You can fix that with a public address, a tunnel, or by running the instance on a server with a real domain. In that configuration, the same GitHub App delivers the webhook and the deploy fires on push. I chose the private network on purpose, and I would choose it again for anything holding a customer list, but it is a trade-off and not a free lunch.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FpqcNLI8DDypCqGIQDWrPw.png" /><figcaption>the deployment history, with the commit, the source and the 36 second build</figcaption></figure><h3>Would I run a business on it?</h3><p>For a one-man trade with forty jobs a year, yes, with two conditions.</p><p>The first is backups. Coolify can schedule database dumps to S3-compatible storage, and a business that cannot restore its job list after a disk failure is a business that lost its invoices. Turn it on the day you deploy, not the week you need it.</p><p>Second, somebody has to patch the host. Coolify updates itself through its own interface, but the server underneath is yours, and an unpatched Docker host is the actual risk in this design. That is the price of owning the platform, and it&#39;s why managed hosting still exists.</p><p>What you get in exchange is a fixed cost and a private database. No per-seat pricing, no vendor reading your customer list, and an address that only your phone can reach. For a trade that keeps its quotes in a notebook, that&#39;s no small thing.</p><p>The job manager code is private, since it is a worked example rather than a product, but the agent skills I build and document this kind of work with are public: <a href="https://github.com/ciberjohn/Hermes-Skills">github.com/ciberjohn/Hermes-Skills</a>. I wrote up the Coolify deployment procedure I used, including the FQDN trap and the API calls, as a skill there so the next deployment doesn&#39;t cost an afternoon.</p><h3>Sources</h3><ul><li>Coolify, source and release notes: <a href="https://github.com/coollabsio/coolify">https://github.com/coollabsio/coolify</a> (v4.5.0, 23 October 2026; repository statistics read 26 October 2026)</li><li>Coolify documentation: <a href="https://coolify.io/docs">https://coolify.io/docs</a></li><li>Upstream defect report: <a href="https://github.com/coollabsio/coolify/issues/12337">coollabsio/coolify#12337</a></li><li>Related merged fix for an undefined Alpine reference: <a href="https://github.com/coollabsio/coolify/pull/4514">coollabsio/coolify#4514</a></li><li>Agent skills used to build and deploy this: <a href="https://github.com/ciberjohn/Hermes-Skills">https://github.com/ciberjohn/Hermes-Skills</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=165c4cb4a851" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[One tab, 41 engines: LibreDB Studio at 1.0]]></title>
            <link>https://joaolealdasilva.medium.com/one-tab-41-engines-libredb-studio-at-1-0-73081ca48605?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/73081ca48605</guid>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[self-hosted]]></category>
            <category><![CDATA[sql-server]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 17:54:37 GMT</pubDate>
            <atom:updated>2026-10-23T17:54:37.735Z</atom:updated>
            <content:encoded><![CDATA[<p>For as long as I have worked with databases, the client has been something you install. A licence per seat, a version per laptop, a saved-password file per machine, and a firewall rule per database so that the whole arrangement can reach the server it was meant to protect. Multiply that by a contractor, a support rota and a second office, and the tool becomes the risk.</p><p>LibreDB Studio inverts the arrangement. The editor is a container that sits beside the data, and people reach it through a browser tab you control. I deployed the 1.0 release, loaded a storefront into PostgreSQL and a warehouse into SQL Server, and used it for an afternoon. It is the first self-hosted database client I have used that does not feel like a compromise you accept for the sake of tidiness.</p><p>This piece covers what actually shipped in 1.0, what it takes to run it, how the editor behaves with real data on two very different engines, the features that earned their place, the rough edges I hit, and the licence detail that the one-line pitch smooths over.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mlqmAAK8aqzV8FJgqWRNIA.png" /><figcaption>The recurring series character in his workshop at night, arms folded in front of a monitor running a SQL editor and data grid, three glowing database servers on the desk each cabled to the one screen, and an entity relationship diagram on the side monitor</figcaption></figure><h3>What shipped, and how fast</h3><p>LibreDB Studio reached 1.0 on 17 October 2026. The repository was created on 23 December 2025, so the project is ten months old, and at the time of writing it carries 1,262 stars, 268 forks and 147 contributors. Those aren&#39;t the numbers of a weekend project, and they aren&#39;t yet the numbers of something battle-tested either. That tension runs through everything below.</p><p>The headline number is 41 database engines behind one interface, from PostgreSQL, MySQL, SQL Server and Oracle through MongoDB, Redis, ClickHouse, Cassandra, Neo4j, Kafka and several protocols that are not SQL at all, including MQTT, OPC UA and Modbus. Another 27 engines speak one of those wire protocols and reuse an existing driver, which is how the project arrives at 68 named engines from 41 drivers. Read the compatibility notes before you trust a number like that for your own estate: the project publishes what works per engine, and some of those entries say plainly that monitoring views are missing or that a row count is not trustworthy.</p><p>Watch the pace. Linuxiac covered the project on 9 September and counted 16 engines. Under six weeks later, the release notes add twelve connection types and call it 41. Whatever else this team is doing, it is not sitting on its hands.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pFMbXt6rI1lbYB0Oo4cYXg.png" /><figcaption>shot-engines.png — the new connection dialogue with the engine picker open, showing the list from PostgreSQL and MySQL down through Kafka, etcd, MQTT and Sparkplug B</figcaption></figure><h3>Three containers and one seed file</h3><p>The deployment is a compose file with three containers: the application, which keeps its own metadata in a SQLite file on a volume, and one PostgreSQL and one SQL Server for the two demo databases. The app image is 750 MB on disk, the PostgreSQL image 454 MB, and SQL Server 1.69 GB, which is simply what Microsoft’s container weighs. Once logged in and idle, the application sits at 102 MiB of memory and 0.02% CPU. It is not the reason your host runs out of anything.</p><p>Two settings matter more than the rest. The first is storage. The default provider keeps connection metadata in the browser, which is fine for a trial and wrong for a team. Set STORAGE_PROVIDER=sqlite (or point it at Postgres) before anybody invests an afternoon in saved queries, because the alternative is a connection list that disappears with the next browser profile and looks exactly like a bug.</p><p>The second is authentication. Local accounts are the default, OIDC is a supported alternative, passkeys work on local accounts, and the admin password can be set at boot rather than scraped from a log. There is an AUTH_BOOTSTRAP=off switch that refuses to invent credentials, which is the setting I would want on anything holding production connection strings.</p><p>Connections can be declared in a YAML file rather than typed by hand, with ${ENV_VAR} substitution so the passwords stay in the environment and a 60-second hot reload when the file changes. That single feature turns the tool from a personal convenience into something an ops team can standardise: a new starter signs in and finds the connections their role can see, with credentials nobody has to paste into a chat window.</p><h3>The editor with a real schema in it</h3><p>I put a synthetic storefront into PostgreSQL: 640 customers, 48 products, 4,200 orders, and 8,400 order items across 18 months, with a view that rolls up revenue by month. Nothing heroic, but enough to make the schema tree, autocomplete, and grid actually work.</p><p>The query I ran most is the boring one every analyst writes:</p><pre>SELECT month, orders, ROUND(revenue, 2) AS revenue<br>FROM shop.monthly_revenue<br>ORDER BY month;</pre><p>Eighteen rows came back in 21 ms. The grid is virtualised, the schema tree shows tables, views, sequences, and triggers as separate groups, and the SQL editor is Monaco, so muscle memory from VS Code transfers without a fight. Tabs, saved queries, a command palette, and inline editing are all there and behave as the labels suggest.</p><p>One thing surprised me. The financial columns came back masked as ***,***.** until I toggled the mask off, because display masking ships with patterns for financial data, email addresses and the rest. That is a good default for a tool people use on calls and in demos, and the project is honest about the limit in its own documentation: masking is a client-side display layer, not a server control. The API response still carries the real value for an authenticated user. Treat it as protection against shoulder-surfing, not against a determined colleague.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4aIeHYrr2VFGnh6U3RPYzw.png" /><figcaption>The query editor with the storefront schema on the left, the monthly revenue query in the middle and 18 rows of results below</figcaption></figure><h3>A different engine, same tab</h3><p>The interesting test is not PostgreSQL, which every tool supports. The real test is whether the same workspace holds up when the second database speaks a different dialect, has different system views, and has a different idea of what a schema is.</p><p>I loaded 640 customers, 40 products, 2,600 orders and 7,800 order items into SQL Server, then ran the query a sales team would actually ask for:</p><pre>SELECT TOP 10 c.full_name, c.country, COUNT(o.order_id) AS orders,<br>       ROUND(SUM(o.total), 2) AS lifetime_value<br>FROM sales.customers c<br>JOIN sales.orders o ON o.customer_id = c.customer_id<br>GROUP BY c.full_name, c.country<br>ORDER BY lifetime_value DESC;</pre><p>Ten rows in 63 ms, with the offset pagination, TOP handling and type mapping all behaving as they should. No restart, no second tool, no export to CSV to move between the two.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FDJukT7bprdJI-tY_jrluA.png" /><figcaption>The same editor is holding a T-SQL query against the SQL Server warehouse, with the top ten customers by lifetime value in the grid</figcaption></figure><p>This is where I hit the one real stumble. A connection seeded against master cannot resolve sales.customers by unqualified name, and the error arrives when you run the query rather than when you save the connection. Point the connection at the right database, or use three-part names. It is a small thing, and it is the kind of small thing that costs a new user ten minutes and some confidence.</p><h3>The features that earned their place</h3><p>A browser IDE that only runs queries would be a thin wrapper around a driver. Three features made me stop treating this as a curiosity.</p><p>The visual execution plan is the best. A join, an aggregate, and a sort produced a six-operation tree with a total cost of 177, with the hash join accounting for 161, plus a plain-language verdict that the query looked fine. That is the difference between a tool an analyst can use and a tool that requires a DBA to interpret a wall of text.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e6iBQ14oP0olqRC-PWCEHg.png" /><figcaption>The visual execution plan for the join, aggregate and sort, with the cost shown on each operation and the six-operation summary above it</figcaption></figure><p>The ER diagram is generated from the live schema rather than drawn by hand, and it exports to PNG and SVG. On my storefront, it found four tables, one view and three relationships, and rendered the foreign keys as real edges. Half the value of a schema diagram is that it stays current; this one cannot drift because it reads the catalogue.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A1eOLOxNeAYiGqfTZQhc3g.png" /><figcaption>The generated entity relationship diagram, four tables and three relationships, with the export controls in the corner</figcaption></figure><p>The monitoring tab reads the engine’s own statistics: two of a hundred connections in use, a 99.8% cache hit ratio, 10.03 MB of data, nine indexes, no deadlocks. The same screens query by database, session, table and storage, and the maintenance actions are named per engine rather than pretending every database has a VACUUM. It will not replace a proper observability stack. It will answer the question you actually have at 11 pm, in the tab you already have open.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZsLtL3Sui2mBJDIist1KKQ.png" /><figcaption>The monitoring overview with connections, database size, cache hit ratio and index count for the PostgreSQL connection</figcaption></figure><p>Charts are drawn straight from the result set, so a revenue trend is two clicks from the query that produced it. It is not a BI tool and does not pretend to be. It is the chart you wanted before you opened the BI tool.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dRC89GcimMDpAiIKSs4eOg.png" /><figcaption>The chart tab with a line chart of monthly revenue drawn from the same query, the axis pickers above it and the eight chart types along the top</figcaption></figure><h3>Where it is still young</h3><p>Ten months old, it answers most of the questions below, and its documentation is unusually candid about several of them.</p><p>The AI agent is the headline feature I couldn&#39;t test honestly because I didn&#39;t attach a model. With no LLM_* variables set, the rail does not render at all, which is the right default: nothing leaves your network until you decide it should. When you do configure one, agent mode runs read-only on PostgreSQL, SQLite, DuckDB, SQL Server, MySQL, Kubernetes and MongoDB.</p><p>The database enforces the boundary wherever a provider implements it, rather than an upstream parser. That is the correct design, and it is still narrower than the engine list. Plan mode works everywhere and runs nothing, which is a sensible place to start if you are cautious about a language model holding a connection.</p><p>Display masking, covered above, is a display layer. The audit log and the two-role model are part of the MIT build, and the 1.0 notes add a governance mode where a separate control plane decides who may open which database with which credential, with credentials sealed to the instance’s public key so the control plane itself cannot read them. That is a serious design choice. It is also the paid tier, which brings me to the sentence I would edit.</p><h3>The licence detail worth reading twice</h3><p>The repository is MIT, and the README says the MIT build holds nothing back: SSO, ER diagrams, the audit log and the AI features all ship in it. That is true, and it is unusual enough to be worth saying twice.</p><p>The paid product is a separate control plane, LibreDB Platform, published as source-available software. It centralises grants, credential sealing, and organisation-wide query records. A single team running one instance does not need it. A company that has to answer “who opened the payroll database, with which account, and what did they run” across forty instances does, and that&#39;s fair to charge for.</p><p>So the pitch is 95% right and 5% marketing. “<em>Nothing behind an enterprise wall”</em> describes the editor, <strong>not</strong> the governance layer. I would rather the project say that plainly, because the architecture is defensible on its own terms, and the exaggeration invites exactly the scepticism the tool doesn&#39;t deserve.</p><h3>What I would do if you run more than two databases</h3><ol><li>Put the instance behind your private network or SSO, <strong>not</strong> on a public port. The whole argument for browser-based access is that one controlled entry point replaces a dozen open ones.</li><li>Set STORAGE_PROVIDER to SQLite or Postgres on day one, then create the admin account properly and leave bootstrap generation off.</li><li>Declare connections in the seed file with environment substitution, so credentials never live in the UI and every role sees the same connections.</li><li>Point SQL Server connections at the database you actually want, not master.</li><li>Start without a model. Add one deliberately, in Plan mode first, and read the data-flow page before you let it anywhere near a production catalogue.</li></ol><p>The measure of a tool like this is not whether it replaces DataGrip or TablePlus for a power user, because it will not, yet. It is whether it removes a class of problem: the laptop full of credentials, the tunnel nobody documented, the contractor who needs six clients to do one job. On that measure, one container and a browser tab is a better answer than it has any right to be at this age.</p><p>The project is young, the interface is dense, and the agent is narrower than the marketing implies. None of that stopped me from leaving it running, and none of it is the interesting part. <strong>The interesting part is that a database client finally stopped being something you install on every machine that needs to touch data.</strong></p><p>If you want the deployment notes and the agent skills I use for this kind of work, they are public at <a href="https://github.com/ciberjohn/Hermes-Skills">github.com/ciberjohn/Hermes-Skills</a>, where the pipeline that produced this article also lives.</p><h3>Sources</h3><ul><li><a href="https://github.com/libredb/libredb-studio">LibreDB Studio repository</a> — README, LICENSE, documentation and issue tracker, read 23 October 2026.</li><li><a href="https://github.com/libredb/libredb-studio/releases/tag/1.0.0">LibreDB Studio 1.0.0 release notes</a> — governance mode, twelve added connection types, the disconnect fix.</li><li><a href="https://libredb.org/">LibreDB Studio project site</a> — install channels and documentation index.</li><li><a href="https://www.postgresql.org/about/news/libredb-studio-an-open-source-self-hosted-sql-ide-for-postgresql-in-the-browser-3368/">PostgreSQL project news item</a> — the listing that first put the project in front of the PostgreSQL community.</li><li><a href="https://linuxiac.com/meet-libredb-studio-a-new-open-source-self-hosted-sql-ide/">Linuxiac coverage, 9 September 2026</a> — an independent count of 16 engines at that point.</li><li><a href="https://github.com/ciberjohn/Hermes-Skills">github.com/ciberjohn/Hermes-Skills</a> — the public skill repository linked above.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=73081ca48605" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The CV you cannot defend in the interview]]></title>
            <link>https://joaolealdasilva.medium.com/the-cv-you-cannot-defend-in-the-interview-94e6292592ae?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/94e6292592ae</guid>
            <category><![CDATA[resume-writing-tips]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[opensource-ai]]></category>
            <category><![CDATA[cv-writing]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 14:44:17 GMT</pubDate>
            <atom:updated>2026-10-07T14:44:17.184Z</atom:updated>
            <content:encoded><![CDATA[<p>I built a small free thing today for people looking for work, and I will come back to it at the end, because it is not the important part. The important part is the failure I keep watching from the other side of the table: capable people sending a CV full of claims that come apart the moment somebody asks a follow-up question.</p><p>That is not a flourish from someone who enjoys interviews. It is the most common way a candidate who looked strong on paper loses a room in ten minutes, and it is almost never a lie. It is a sentence a reader took from a job advert, a number a well-meaning assistant made up, or a verb that sounded better than the truth.</p><p>What follows is the method, in the order I would do it: what the machine reads before a human gets a look, the one rule that keeps you out of trouble, how to aim a CV at a single advert rather than everything at once, the language that makes a recruiter stop reading, and what to do about LinkedIn, which is where most of the searching happens anyway.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SnGBk5K1tTRoR0-xS5mJcw.png" /><figcaption><em>This image was created using an AI image creation program.</em></figcaption></figure><h3>A machine reads it first, and it is not subtle</h3><p>Most applications go through an applicant tracking system before any human sees them, and those systems were built to read a document, not to admire a design. One column. Plain section headings. Dates in the same format every time. Contact details in the body of the page rather than in a header, because headers get dropped. No tables, no text boxes, no icons, no sidebars, and no photograph, however good it looks on your screen.</p><p>That last one annoys people, and I understand why. It also costs you nothing to comply.</p><p>Then there is the part that everyone gets wrong. Keywords do matter, because the system and the recruiter are both matching your words against the advert, but the honest version of that job is small: if the advert says incident response, and you have done incident response, use their words for it rather than your employer’s internal vocabulary for the same work. White text, hidden rows and micro-fonts are fraud with extra steps, and modern parsers strip them out before a human ever gets the chance to be impressed.</p><h3>The rule that keeps you out of trouble</h3><p>Write from evidence. Not from ambition, not from the version of the job you would like to have had.</p><p>In practice, I split it three ways, and people get caught in the middle. Changing the wording, the order and the emphasis is free, and it is where most of the improvement lives. Changing the title you present is fine if you add a truthful qualifier, which is how “Support Analyst” becomes “IT Support Analyst (helpdesk lead of three)” when you really did lead three people. Everything else, which means every number, every date, every tool, every qualification and every scope, needs to come from you rather than from the machine, because those are the things an interviewer pulls on.</p><p>The test I would apply to every line is simple enough to run in your head: if someone asks me about this for two minutes, can I answer without improvising? If the answer is no, the line does not go in. It goes into a list of gaps, and gaps are genuinely useful, because a gap you know about is a question you can prepare for.</p><h3>One CV per job, not one CV for everything</h3><p>The instinct is to have a CV and send it everywhere. The result is a document that fits no one.</p><p>Take one advert, the one you actually want, and pull it apart on paper: the exact job title as they wrote it, the must-have requirements, the nice-to-haves, the tools they name, the qualifications, and the seniority signals (“hands-on”, “lead”, “senior”). Then put your own evidence next to each requirement and mark it honestly: this one I match, this one I partly match, this one I do not have.</p><p>The number that comes out of that exercise, the count of must-haves you genuinely match, tells you whether to apply at all, and that is worth knowing before you spend an evening on it. More usefully, it tells you what to put at the top. The three or four requirements you match best go into the first paragraph and the top three bullets of your most recent role, not buried under a summary of your career history.</p><p>And the requirements you do not match? Leave them out of the CV. A claim you cannot support is worse than a gap you never mentioned, because the gap is invisible and the claim is a trap you set for yourself.</p><p>The partial matches are the interesting ones, and they are where careful writing earns its keep. State the thing at its true size. If they want someone who has run a team of twenty and you have run six, say six, then add what you did with those six, because six with a result beats twenty with an adjective, and the interviewer will find out the number anyway.</p><h3>The words that make a reader stop</h3><p>This is the part that has changed most in the last two years, and it has changed because of us rather than recruiters.</p><p>The old problem was CV clichés, and they are still with us: results-driven, detail-oriented, dynamic self-starter, team player, passionate about, proven track record, responsible for. They are not wrong exactly. They are empty, and a reader who has seen four hundred of them this month skips them, which means the space they occupy in a two-page document is space you paid for and did not use.</p><p>The new problem is machine-written text pasted without editing. There is now a whole vocabulary for it, and the tells are consistent, so I will name them rather than describe them, because you cannot delete a habit you cannot see: delve, leverage, utilise, spearhead, harness, showcase, enhance, foster, robust, comprehensive, seamless, meticulous, pivotal. Add the shapes that give it away: everything arriving in threes, three sentences in a row of the same length, the same paragraph structure repeated down the page, and the em dash habit.</p><p>LinkedIn has noticed, in the most direct way it can. During 2026, the platform added a “seems like AI slop” report option to posts and comments, and its own published definition of slop is content that sounds polished but carries no point of view, no perspective and no substance. LinkedIn has been careful to say the question isn&#39;t how something was written, but whether it adds value, and it recommends that anything a model drafts for you be reviewed and edited before it goes out.</p><p>You may have read that AI detectors can catch this for you. They cannot, reliably, and the numbers are worth knowing. OpenAI withdrew its own classifier after it identified around a quarter of machine-written passages correctly while flagging a good deal of human writing as machine-made, and a Stanford study put false positives on human essays above sixty per cent. The judge is not a detector. The judge is the recruiter who has read a thousand of these and can smell the average.</p><h3>What to do about LinkedIn</h3><p>Most people applying for jobs spend their effort on the CV and leave their profile to chance, which is backwards, because recruiters search the profile whether or not there is an advert open.</p><p>Three things matter more than the rest. Your headline gets 220 characters, and it is the field the search weights most heavily, yet most people leave it as a job title; name the role in the market’s words, add the tools and specialisms someone would search for, and get the important part into the first seventy characters, because that is all that shows in a result. Your About section gets 2,600 characters and only about the first 300 are visible before the fold, so those 300 have to stand alone. Your skills list is a filter, so put the tools you want to be filtered by near the top and pin the three that matter.</p><p>One practical detail that saves an hour. LinkedIn’s own Save to PDF export <strong>only works properly on English profiles</strong> with the account language set to English, and in 2026 it stopped working for a number of accounts entirely. If it gives you nothing, use the data archive instead: Settings and Privacy, then Data privacy, then “Get a copy of your data.” You get plain-text files with your whole profile in about ten minutes, in any language, with the parts the PDF drops.</p><h3>The thing I built, and what you can ignore</h3><p>Everything above is the substance, and you can do it all by hand with a chat window and an evening.</p><p>What I built today is free and MIT-licensed, and it exists so the work above happens in the right order instead of getting forgotten at the end. It comes in two shapes. One is a set of project instructions you paste into a Claude Project, a ChatGPT Project or a custom GPT, upload your CV to once, and then drive with commands. The other is a pack of eleven prompts you paste into any chat, including a free one on a phone, with no setup at all and nothing to install. Both do the same three things: they force the machine to build an evidence file from your CV rather than free-associate about your career, they aim the rewrite at one advert and report what you genuinely match, and they run a language pass against the slop vocabulary before exporting anything. There&#39;s also a branch for the LinkedIn profile, and a checker that runs in English and European Portuguese.</p><p>It is at <a href="https://github.com/ciberjohn/cv-tailor-project">github.com/ciberjohn/cv-tailor-project</a>. Take it, change it, hand it to someone who needs it.</p><h3>What I would do on Monday</h3><p>Pick one advert, the one you actually want. Write out your evidence first, in your own words, with the numbers you can defend, because everything else flows from that file. Then rewrite the top third of the CV against that advert only. Then read every sentence aloud and delete the ones you would never say to a colleague.</p><p>After that, spend twenty minutes on your LinkedIn headline, because it does more work for you than the CV and it does it every day. Then message two former colleagues and ask for a recommendation that names a specific project, and make it easy for them by drafting it yourself.</p><p>The last thing, and it is the one I would want you to keep: your CV is not a document about your potential. It is a short, provable account of work you have actually done. Write that, and defend every line of it, and you will be in a much smaller group than you think.</p><h3>Sources</h3><ul><li><a href="https://github.com/ciberjohn/cv-tailor-project">cv-tailor-project</a> my own repository: drop-in project instructions, an eleven-prompt pack for plain chats, the anti-slop rule set with an English and European Portuguese checker, and the LinkedIn branch. MIT licensed.</li><li><a href="https://www.linkedin.com/help/linkedin/answer/a541960/save-a-profile-as-a-pdf">LinkedIn: save a profile as a PDF</a> LinkedIn’s own help page, which is where the English-only limitation and the desktop-only scope come from.</li><li><a href="https://www.linkedin.com/help/linkedin/answer/a566336">LinkedIn: get a copy of your data</a> the data archive route, which returns the profile as plain-text files in any language.</li><li><a href="https://www.viralbrain.ai/tools/linkedin-character-limits">LinkedIn character limits, 2026</a> the headline, About and experience limits quoted above, with the visible-before-cutoff figures.</li><li><a href="https://www.medianama.com/2026/08/223-linkedin-ai-slop-ai-assisted-writing/">How LinkedIn distinguishes AI slop from AI-assisted writing</a> the platform’s own definition of slop, the report option, and what it says about reviewing AI-assisted output.</li><li><a href="https://www.hiration.com/blog/ai-slop-linkedin/">Is AI writing your LinkedIn hurting you?</a> the detector-accuracy figures, including the withdrawn OpenAI classifier and the Stanford false-positive study.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94e6292592ae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Always-on AI coworkers, without the $100 subscription to use Dots]]></title>
            <link>https://joaolealdasilva.medium.com/always-on-ai-coworkers-without-the-100-subscription-to-use-dots-33dd36dbd354?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/33dd36dbd354</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[open-source-ai]]></category>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[small-business]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Sun, 04 Oct 2026 14:35:11 GMT</pubDate>
            <atom:updated>2026-10-04T14:35:11.748Z</atom:updated>
            <content:encoded><![CDATA[<p>I spent a morning building OpenDots in a throwaway Linux container with four cores and six gigabytes of memory, pointing it at a pay-as-you-go model endpoint, and then sitting on the other side of the table asking it the questions a small restaurant owner and a self-employed plumber would ask.</p><p>It answered both. One of the answers was good enough that I would have sent it to a potential customer with a few numbers filled in, and the research it did for the plumber came back with sources and an honest note that two of those sources disagreed with each other about how many people search for the phrase in question.</p><p>It also has a dependency the word “self-hosted” doesn&#39;t prepare you for, and if you are a business owner thinking about running your own always-on AI assistant, that is the part you need to know before you read anything else.</p><p>This article covers what Dots are and who can buy one, what OpenDots is, what I installed and measured, the two small-business scenarios I put it through, and the catch underneath it all.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E_l36lc3TqyRAoAUfhqQ9w.png" /></figure><h4>What Dots are, and who is allowed to buy one</h4><p>At its developer conference in September, OpenAI announced Dots: always-on agents that live inside ChatGPT, each with its own cloud computer and browser, that keep working after you close the tab and come back to you with finished work. The pitch is a personal assistant with a memory and a machine, rather than a chat window you have to keep re-explaining yourself to.</p><p>As the tech press reported, the details matter more than the demo. Each Dot runs on GPT-6 Astra and can connect to more than four thousand apps through the plugin ecosystem. You get one primary Dot per person at launch. And the part that decides everything for a small business: Dots are for ChatGPT Pro and Business Premium subscribers, with the entry point at a hundred dollars a month, and Pro subscribers in the UK, the EEA and Switzerland were excluded when it launched.</p><p>Read that last sentence again if you run a business in Britain, because it means the product I am about to describe an alternative to was not on sale to you.</p><h4>What OpenDots is</h4><p>OpenDots is CopilotKit’s open-source answer. It is a template rather than a product: you clone it, run it, configure it, and change it. It is MIT licensed, which in plain terms means you can use it commercially, modify it, and not pay anybody a licence fee.</p><p>The project was published at the end of September and had 2,908 stars on GitHub by the first week of October, which for a repository five days old tells you how much appetite there is for this category. It is honest about being early: the README says “alpha” at the top and the feature table separates what the authors have verified locally from what still needs testing against connected services.</p><h4>In shape, it is three things:</h4><p>- <strong>Dots</strong>. Named assistants with their own role, instructions and permitted tools. A researcher can be told to investigate, a writer to produce the draft. You decide which areas of your workspace each one may touch.<br>- <strong>Spaces and pages</strong>. A home for the documents the work produces. Pages live in a local database on your machine, are searchable, and open in a proper editor with headings, lists, tables and an undo history. Writing in them works with no external service connected.<br>- <strong>Tools</strong>. Optional extras: a read-only browser service for public web research, a voice channel, a Slack connection, and, the big one, the ability for a Dot to have its own computer with a browser, files and a terminal.</p><p>The claim that made me want to test it is the one about models. You bring your own: any OpenAI-compatible endpoint works, so you are not tied to one vendor’s pricing or region.</p><h4>What I actually put in front of it</h4><p>I didn&#39;t want to review a landing page, so I built it properly. The Linux Container (LXC) I used was deliberately unremarkable: four processor cores, six gigabytes of memory, forty gigabytes of disk, no graphics card, no cloud account. I installed Node.js 24, cloned the repository, installed the dependencies, built it, and ran it as a service that restarts if it falls over.</p><p>The only two credentials it needed were a model endpoint and a CopilotKit Intelligence project key, which I will come back to, because that second one is the interesting part.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qBnqqZinsHJHq00qGUuspQ.png" /><figcaption>opendots-setup.png — the setup panel, reporting the one missing credential before the Intelligence key was added</figcaption></figure><p>Then I talked to it. Twice, as two different people.</p><h4>Scenario one: the restaurant</h4><p>The first role I took was a restaurant owner with twenty-eight covers, which is small enough that an empty table is a visible hole in the night and big enough that booking admin eats an evening a week. I asked for a reservations policy for the website, in plain English, with no legal jargon, covering no-shows, groups of six or more, and how much notice we need for cancellations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vY5N957ZKQnKOPB4fwmouQ.png" /><figcaption>the reservations policy it drafted, including the blanks left for the owner to decide</figcaption></figure><p>What came back was better than I expected, and not because it was fluent. It was better because it understood which numbers were the owner’s decisions rather than its own, and it left them as clearly marked blanks instead of inventing a cancellation fee and hoping I would not notice. A no-show charge, a group deposit, and the largest table size the room can serve: three decisions that belong to the person who owns the risk, presented as three decisions.</p><p>Two things in that answer are the sort of detail you normally only get from someone who has actually run a small venue. The first: it said the policy page is the least useful place for those terms, because the wording has to be visible at the moment of booking, on the booking form and in the confirmation email, and that is what makes a charge stick if a customer disputes it later. The second: it flagged that taking card details to hold a table needs a payment provider that supports card holds, and that this is worth checking before promising customers a deposit scheme.</p><p>Neither of those is a writing task. Both are the difference between a policy that exists and a policy that works.</p><p>Then I asked it to save the draft as a page and write the friendlier version for the booking confirmation email. It did both and told me where the page had gone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RPh7FLArGLO62d5usgNpCg.png" /><figcaption>the draft saved as an editable page in the Space, with the save confirmed in the conversation</figcaption></figure><p>The follow-up text came back with a short explanation of why it reads differently from the policy page: the page has to be complete and unambiguous in case it is ever the thing that settles a dispute, while the email has one job, which is to make someone feel looked after while quietly making sure they have seen the notice windows. It also warned me to keep the numbers in the email rather than softening them, and to cut the group-booking paragraph for small tables, because a couple reading about deposits and set menus will wonder what they signed up for.</p><p>That is the level of judgement I would want from a junior manager, and it arrived in a couple of minutes.</p><h4>Scenario two: the plumber</h4><p>The second role was a plumber working alone in a small town, and the question was whether he is the first name people think of: what do homeowners actually search for when they need a plumber, especially out of hours, and what should go at the top of his website.</p><p>This is where the research path runs, and I want to be precise about what happened, because “AI does research” is a claim that deserves scrutiny. The Dot went out to the web through a server-side search provider, got a structured answer, and listed its sources underneath in four groups: keyword data, what belongs above the fold on a trade website, local and mobile search behaviour, and the cost of missed calls.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YdtB4Z5Ex7sUu2KoKXf-PA.png" /><figcaption>the structure of the research answer, with the three recommendations</figcaption></figure><p>The recommendations themselves were sensible and specific: a headline that names the problem, the town and the hours in that order, rather than a generic promise of quality; a large tappable phone number in the header, sticky on mobile, paired with a plain promise about what happens when someone calls it; and trust proof on that same first screen, including the licence number stated plainly rather than buried in the footer.</p><p>It also volunteered the operational point that matters more than the website. The figures it cited put roughly half of inbound plumbing calls outside normal hours, and it said most people who get voicemail at two in the morning do not leave a message; they call the next name on the list. Those numbers come from the sources it just read rather than anything I measured, and the direction matters: a website advertising twenty-four-hour coverage while the phone rings out is worse than one that says emergencies are answered until ten, and everything else is next day.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vktR-MSp5b4jk64Qb3FaOw.png" /><figcaption>the sources list, and the tool’s own note that two of its keyword sources disagree by a factor of two</figcaption></figure><p>The part I want to highlight, though, is the caveat it wrote for itself. The keyword volumes it found came from third-party marketing tools, and those tools contradict each other: one reports the main search phrase at 27,100 searches a month and another at 60,500. The Dot said so explicitly, told me to treat those numbers as evidence of intent rather than precise volume, and noted that national figures say nothing about demand in one town.</p><p>An assistant that tells you which of its own numbers are soft, unprompted, is doing something more useful than being confident. If you are the plumber, that caveat is the difference between a marketing decision and a guess.</p><h4>What I would actually buy it for</h4><p>Strip away the agent vocabulary, and the honest summary is that this is a competent, fast colleague who doesn&#39;t need to be told what a small business is.</p><p>For the restaurant, the value isn&#39;t the policy document; it is having a first draft of every awkward piece of writing a small venue generates: the terms, the confirmation email, the reply to a complaint, the seasonal menu description, the note to the supplier who short-shipped you.</p><p>For the plumber, the value is staying current without setting aside an evening a week. Asking what customers are searching for, what competitors are saying, which new regulations affect your trade, and getting a sourced answer in two minutes is a real change to how a sole trader keeps up. That is what being the person the town calls first looks like when it is maintained, not accidental.</p><p>Both of those are text and documents. That is worth saying plainly, because the demo videos you have probably seen show more than that.</p><h4>The catch: the phrase “self-hosted” is doing less work than you think</h4><p>The detail I want to know before spending a weekend on this is in the source code, not the marketing.</p><p>OpenDots stores your pages, your Spaces and your Dot configuration in a database on your own machine, and that part is genuinely self-hosted. But the conversation history does not live there. CopilotKit Intelligence persists conversations, and it&#39;s a hosted service you can&#39;t disable with a setting. The relevant line in the server code returns early if no Intelligence key is present, which means that without it there is no chat runtime at all: the pages work, the editor works, and every conversation fails with a message telling you the key is missing.</p><p>So in practice you have two ways to run this. You take a free project key on CopilotKit’s hosted service, which is what I did and which needed a browser sign-in once, and you accept that your conversations are stored on somebody else’s infrastructure. Or you self-host Intelligence as well, which is a different scale of project: a Kubernetes or AWS deployment, plus a paid plan to go with it. The local evaluation option runs in containers on your own machine, is macOS-only, and the licence lasts thirty days.</p><p>That is not a fatal objection. Plenty of businesses will not care where the chat history lives, and the free tier covers the testing I did. But “self-hostable open-source alternative” and “your conversations are persisted by a vendor” are two sentences that need to be read together, and the second one is easy to miss in the launch-day excitement.</p><p>The same pattern runs through the other features, in a milder form. The per-Dot computer, meaning its own browser, files and terminal, needs a second set of container services built and connected. Voice needs a separate real-time speech provider, and pointing the model at a different endpoint does not redirect the voice traffic. Slack needs a managed channel set up through the vendor’s own tooling. None of that is hidden, and the project’s own documentation is unusually clear that these pieces are separate, but the gap between the demo and your first working day is real, and it is made of these.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*05WodAZ_EU9Tbs_zUnchyw.png" /><figcaption>the service panel after my test: text configured and confirmed by a real conversation, with Slack and voice still needing their own providers</figcaption></figure><h4>What it needs from you, and what it costs</h4><p>The template is free. The model isn&#39;t, because you pay per use for whichever endpoint you connect, and how much you pay depends entirely on what you ask it to do and which model you choose. That is the honest shape of it: no subscription, no seat licence, a bill that scales with usage, and a project key from a hosted service if you want conversations to persist.</p><p>What it needs from a person is a few hours of competence, not expertise. Install Node, run three commands, edit a configuration file, and start a service. If you have anyone who has ever deployed a web application, that is an afternoon. If nobody in your business has, this is not a first project, and paying someone for two hours is cheaper than a weekend of your own.</p><p>I would also say this plainly: the Intelligence sign-in is a browser step, and it is the point where a non-technical owner will want someone sitting next to them. It is not hard; it is just not obvious.</p><h4>What I would do in your position</h4><p>If you run a small business and you want an assistant that knows your business today, with no hosting at all, there is a cheaper first step. I keep a public collection of fifty-two ready-to-deploy agents for Microsoft Copilot Chat, aimed at organisations of this size, covering writing, finance, HR, IT operations, sales, and engineering. You paste an instruction block into Copilot Studio, and you are live on any commercial Microsoft 365 licence, with no coding and no container. It is licensed CC BY-SA 4.0 and the repository is at [github.com/ciberjohn/awesome-copilot-chat-agents](<a href="https://github.com/ciberjohn/awesome-copilot-chat-agents">https://github.com/ciberjohn/awesome-copilot-chat-agents</a>). That is the low-effort path, and for most small businesses it is the right one to try first.</p><p>If you have a technical person available, or you are one, then OpenDots is worth the afternoon. It ran on modest hardware; it answered both of my scenarios in a way that would have taken me an hour to match by hand, and the ability to point it at whichever model endpoint you prefer is a genuine advantage over anything subscription-shaped. Go in knowing that your conversations live with a vendor unless you take on a much bigger hosting project, and that the computer-per-Dot features are a second piece of work rather than a checkbox.</p><p>The wider point is the one I keep coming back to. A year ago the always-on agent with its own computer was a product you bought for a hundred dollars a month, in a country that was allowed to buy it. Now it is a repository you can clone, on a licence that lets you use it commercially, running in a container on hardware that costs less than the subscription did. The gap between those two things is closing faster than the marketing has caught up with, and the interesting question for a small business is no longer whether this is possible. It is who in your business will own it.</p><h3>Sources</h3><p>- [OpenDots repository](<a href="https://github.com/CopilotKit/OpenDots">https://github.com/CopilotKit/OpenDots</a>) — the subject of this piece: MIT licensed, the template I cloned and ran (commit `c2569bb`), 2,908 stars and 365 forks as of 4 October 2026.<br>- [OpenDots setup documentation](<a href="https://github.com/CopilotKit/OpenDots/blob/main/docs/SETUP.md">https://github.com/CopilotKit/OpenDots/blob/main/docs/SETUP.md</a>) — the installation, conversation-services and container instructions I followed.<br>- [CopilotKit: introducing OpenDots](<a href="https://www.copilotkit.ai/blog/introducing-opendots">https://www.copilotkit.ai/blog/introducing-opendots</a>) — the project’s own launch post, including the statement that it is an early single-owner starting point.<br>- [CopilotKit Intelligence overview](<a href="https://docs.copilotkit.ai/intelligence/overview">https://docs.copilotkit.ai/intelligence/overview</a>) — hosted, self-hosted and local evaluation, which is where the persistence dependency in this article comes from.<br>- [Evaluate Intelligence locally](<a href="https://docs.copilotkit.ai/intelligence/self-hosting-local">https://docs.copilotkit.ai/intelligence/self-hosting-local</a>) — the macOS-only, thirty-day local evaluation path.<br>- [Self-hosting Enterprise Intelligence](<a href="https://docs.copilotkit.ai/premium/self-hosting">https://docs.copilotkit.ai/premium/self-hosting</a>) — what running the persistence layer yourself actually requires.<br>- [Parallel Search MCP](<a href="https://docs.parallel.ai/integrations/mcp/search-mcp">https://docs.parallel.ai/integrations/mcp/search-mcp</a>) — the research provider the template uses by default, and what it receives.<br>- [Tom’s Guide: Meta Muse vs ChatGPT Dots](<a href="https://www.tomsguide.com/ai/meta-muse-vs-chatgpt-dots-i-compared-the-new-ai-agents-and-theyre-not-as-similar-as-they-look">https://www.tomsguide.com/ai/meta-muse-vs-chatgpt-dots-i-compared-the-new-ai-agents-and-theyre-not-as-similar-as-they-look</a>) — press reporting used for the Dots pricing, plan eligibility and regional availability in this article.<br>- [ZDNET: ChatGPT Space, Pages and slides](<a href="https://www.zdnet.com/innovation/chatgpt-space-pages-slides-google-workspace-alternative/">https://www.zdnet.com/innovation/chatgpt-space-pages-slides-google-workspace-alternative/</a>) — press reporting on Dots inside ChatGPT.<br>- [awesome-copilot-chat-agents](<a href="https://github.com/ciberjohn/awesome-copilot-chat-agents">https://github.com/ciberjohn/awesome-copilot-chat-agents</a>) — my own public collection of fifty-two paste-and-go Copilot Chat agents, CC BY-SA 4.0, referenced in the closing section.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=33dd36dbd354" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Gave My Hermes Agent JEV, and It Stopped Writing Paragraphs to Answer Yes or No]]></title>
            <link>https://joaolealdasilva.medium.com/i-gave-my-hermes-agent-jev-and-it-stopped-writing-paragraphs-to-answer-yes-or-no-35c965b42c66?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/35c965b42c66</guid>
            <category><![CDATA[opensource-ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[jevs]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Thu, 01 Oct 2026 05:42:33 GMT</pubDate>
            <atom:updated>2026-10-01T05:42:33.709Z</atom:updated>
            <content:encoded><![CDATA[<p>Most of what I ask my agents isn’t a writing request. It’s a request for a decision.</p><p>Which of the nine should take this one? Does it need me before it starts? Is this urgent, or just loud? Does that line contain a live credential? Four questions, four answers, and not one of them is a sentence.</p><p>For a long time, I bought those answers the only way I knew how. I asked a language model for a paragraph, then read it looking for the word I actually wanted. Sometimes the word came first. Sometimes the reply opened with “Certainly!” and put the word on the fourth line. Sometimes it came back empty, and I assumed I’d done something wrong. I hadn’t.</p><p>Jev is a TypeSafe model built to refuse that arrangement. You send it your text and your questions; it sends back answers of the type you asked for, with probabilities attached, and your code branches on the values instead of reading prose. I installed TypeSafe’s own agent skill into my Hermes fleet, used it to build a small routing gate for the officers, and ran it all today on one laptop.</p><p>This article covers what Jev actually is and what it flatly refuses to do, how I installed it by asking rather than coding, how the same skill now sits in every one of my agent profiles with its own key, what happened when I pointed it at a real routing problem, and how it changes the quality, the speed and the cost of a decision. There’s also an honest section on where it doesn’t behave as you’d hope, and a short caution about buying access from the wrong shop.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kmCNWZFnSd-zQGaQUVbo8A.png" /></figure><h3>What Jev Is, and What It Refuses To Be</h3><p>Start with the refusal, because it’s the whole design, and TypeSafe is unusually blunt about it. Their own documentation says System One models “do not write replies, produce code, or generate explanations of their reasoning.” There’s no chain of thought to inspect, because there’s no thinking in the generative sense. There’s a judgment, and it comes back as a number or a label.</p><p>That sounds like a limitation until you’ve spent an afternoon parsing one-word answers out of three-paragraph replies. The thing you need to notice is that Jev’s response shape is fixed by your request. You can’t get a paragraph back by accident, and you can’t get one back by asking nicely. If you ask whether a line contains a password, you get a probability. If you ask which of nine agents should handle a job, you get one of those nine names, plus how the model split its belief across the others. Ask a bad question, and you get a bad answer, but you never get a hallucinated response shape, and you never get silence wrapped in a polite apology.</p><p>There are three kinds of questions, and the differences matter more than they should.</p><p>A Noul is a yes-or-no question. You get back one number between zero and one: the probability the answer is yes. There’s no separate confidence field, which annoyed me at first and then made sense. For a binary question, the probability is the information.</p><p>A Choice picks one option from a set you define. You get the chosen option, a probability for every option in that set, and a confidence. The extra probabilities are the useful part. If a request routes to one officer at 0.66 with a second one sitting at 0.34, you have a genuine near-miss on your hands, and you can decide what to do about it. If it routes at 0.98, you don’t need to look again.</p><p>A Score places content on an ordered scale you describe, and returns a position along it. Tell it the levels are “a quick answer”, “one focused task”, and “multi-step work”, and it will tell you this request sits at 1.34, with the probability mass split between the first two.</p><p>It is not a smaller, cheaper language model. It doesn’t summarise, it doesn’t write, it doesn’t explain itself, and you can’t talk it out of an answer with text hidden in the thing you asked it to judge, because there’s no generation step for an injection to steer. That last property is the one I keep coming back to. If you have ever pasted a suspicious document into a model and hoped its instructions were strong enough, you’ll understand why a model with nothing to instruct is a different kind of tool.</p><h3>How I Installed It, Without Writing an Integration</h3><p>I didn’t write any integration code. I asked for one, in English, in a Hermes session.</p><p>Hermes agents extend by skill. A skill is a folder of instructions and scripts that the agent loads when a task matches it, and I publish mine <a href="https://github.com/ciberjohn/Hermes-Skills">on GitHub</a>, so adding a capability is usually a matter of installing someone else’s. TypeSafe ships an agent skill upstream in an MIT-licensed repository. I repackaged it for Hermes, and then the install itself was a paragraph of plain English pasted into a session: copy this folder here, add the key there, then check the copy is intact before you use it.</p><p>The agent did the copying, found the right .env file, and ran the verification. That&#39;s the part worth dwelling on, because it&#39;s the difference between this and a library. Nothing in that install needed me to read a header file, resolve a dependency, or remember where a config lives. I described the outcome and the agent worked out the mechanics, which is exactly what I want an agent for.</p><p>Using it is the same shape. In any session, I can type <em>“use the jev skill to check whether these forty support tickets are urgent, then tell me which to answer first”</em> and the skill loads. The caller script resolves the API key from the environment or from the profile’s .env file, so the secret never sits in a command line where the process list can read it, and it never ends up in shell history. I care about that more than it probably reads. An API key in a command line is an API key in your shell history, your process table and whatever log captures the command.</p><p>My own skills don’t reach a repository in one hop either. New ones pass through a meta-skill that generates the package, sanitises it, and dispatches three reviewers in parallel, all of them mandatory: a DevSecOps reviewer for secrets and unsafe defaults, a QA reviewer checking that the code and the documentation agree, and a technical writer who opens every external source in a browser to confirm it still says what the skill claims. Only after that does anything get committed. The Jev skill went through that gate, which is how the credential handling ended up as careful as it is.</p><h3>Installing It, If You Want It</h3><p>The install is small enough to paste. This is the prompt from the repository README, and it works on any Hermes profile:</p><pre>I want to install the jev skill from github.com/ciberjohn/Hermes-Skills.<br>Copy the whole jev/ folder - SKILL.md, README.md and every file in scripts/<br>(jev-call.sh, jev-triage.sh, sync-to-profiles.sh, update-from-upstream.sh) - into<br>~/.hermes/skills/autonomous-ai-agents/jev/.</pre><pre>Then add TYPESAFE_API_KEY to my Hermes profile .env (mint a key in the<br>TypeSafe console dashboard, <a href="https://console.typesafe.ai/keys)">https://console.typesafe.ai/keys)</a> and verify with<br>~/.hermes/skills/autonomous-ai-agents/jev/scripts/jev-call.sh</pre><pre>Finally, confirm the copy is intact before anything else:<br>cd ~/.hermes/skills/autonomous-ai-agents/jev &amp;&amp; sha256sum -c MANIFEST.sha256</pre><p>If you’d rather do it by hand:</p><pre>git clone https://github.com/ciberjohn/Hermes-Skills.git ~/Hermes-Skills<br>mkdir -p ~/.hermes/skills/autonomous-ai-agents<br>cp -r ~/Hermes-Skills/jev ~/.hermes/skills/autonomous-ai-agents/jev<br>chmod +x ~/.hermes/skills/autonomous-ai-agents/jev/scripts/*.sh<br># add TYPESAFE_API_KEY to ~/.hermes/.env, then:<br>cd ~/.hermes/skills/autonomous-ai-agents/jev &amp;&amp; sha256sum -c MANIFEST.sha256</pre><p>Two things about that, because they’re the sort of detail that decides whether you trust an artefact you found on the internet. The manifest covers the skill file and all four scripts, so you can verify the copy you fetched against the checksums I published rather than taking my word for it. The upstream body is TypeSafe’s own, kept verbatim apart from the frontmatter, a prepended header, and one dead documentation link I refreshed. I recorded the upstream git blob SHA-1, and there’s a script in the folder that re-pulls upstream and compares its hash, so you can see for yourself whether the copy has drifted.</p><p>One caution, and it’s not hypothetical. When I researched this model for the <a href="https://www.youtube.com/@costaruitiago/streams">podcast</a> <em>(episode where I talk about this not aired at the date of this story publishing)</em>, the pattern that came up was ugly: three days after TypeSafe launched Jev, a search for its name put a site that wasn’t TypeSafe at the top of the results, complete with API documentation, a playground, pricing tiers and a checkout. Those shopfronts sold TypeSafe’s own API, forwarded, at between three and eleven and a half times the official rate, with your prompts passing through a third party and no contract behind them. Eye Security wrote the research up, and they were careful to say it isn’t illegal as far as they can tell. So do the boring thing: mint your key at the console, install the skill from a repository you’ve looked at, and check the domain your code actually posts to. The first search result is a supply chain, and it’s the one nobody audits.</p><h3>One Skill, Nine Agents, One Routing Decision</h3><p>My fleet runs nine agent profiles, each an independent agent with its own skills, credentials and scheduled jobs. Spock is the science officer and the one I talk to; Scotty is the chief engineer and owns the servers; Uhura handles communications, email and the content pipelines; Bones gives health and fitness guidance; Sulu is my business consultant; Nurse Chapel is the technical author; Cyrano advises on crypto and stocks; Data runs the home automation host; Quark executes the small live trades.</p><p>Every one of them now has the same Jev skill, and each profile carries its own API key in its own .env file. Nine copies of one folder, byte-identical, verified by checksum after copying. There&#39;s nothing per-profile to configure, no gateway restart to remember, and no service for me to keep alive. And because the skill only loads when a task matches it, it costs nothing to have it sitting in a profile that rarely needs a judgment.</p><p>That’s the static half. The interesting half is what I built with it today, and I built it the same way: by describing it.</p><p>I wanted one command that takes a request in plain English and tells me which officer should take it, whether it needs me first, how much work it represents, and whether the text contains a secret that must not be echoed. Four questions, one request, typed answers. The roster of officers is a text file with one line per agent describing the work that agent does, because that description is the routing policy. Write it as job titles, and you’ll get job titles back.</p><p>Then I ran five real requests through it. These are the actual answers, and I’m giving you the awkward ones as well as the clean ones, because the awkward ones are where the value sits.</p><p>A stale Medium feed cache that might or might not have been refreshed by a morning job routed to Uhura at 0.66, with Scotty, who owns the machine the job runs on, close behind at 0.34. That’s a fair split, and it’s the sort of request I’d have guessed. A question about UK VAT rules for a one-person consultancy from a friend of mine went to Sulu at 0.98. My 3D printer lifting its first layer on a new spool routed to Spock at 0.68, with Scotty at 0.22, which tells me the model isn’t sure whether that’s a creative-project problem or an engineering one either. I’d call that honest.</p><p>Then the two that earned their place. A request containing a key-shaped string routed to Scotty at 1.00, correctly, and the credential question came back at 0.94, while the same request’s “does this need you” question read 0.32. So the gate flags the secret and still routes the work. And a question about whether to cut a losing position came back 0.53 for one agent against 0.45 for the other, with “does this need you” at 0.67. The routing was close to a coin toss, and the model said so with its distribution, while the decision to involve me came back clearly. That’s the behaviour I want from a gate: confident where it should be, visibly uncertain where the question is genuinely close.</p><p>One reading habit worth acquiring, because I got it wrong the first time. The number the API calls confidence is not the winning option’s probability. It measures how concentrated the distribution is, so a route at 0.66 can carry a confidence of 0.62, and both are correct. Read them as one figure, and you’ll quote a near-tie as a certainty.</p><p>None of that is a prompt I have to police. I’m not asking a language model to answer with a single word and hoping. I’m reading values, and the runner-up score comes back whether I asked for it or not.</p><h3>Better, Faster, Cheaper</h3><p>Better is the easiest of the three to argue, and on the evidence I have, it’s mostly about shape. A typed answer can’t be malformed, so there’s no parsing layer to write and no failure mode where a good decision arrives in an unreadable form. The scale is the same on every call, which matters when I’m grading documents: ask the same three questions of forty drafts, and I can compare the numbers, whereas a language model re-rolls its phrasing and its scale every time and gives me forty slightly different rulers.</p><p>Faster I measured, on one laptop over home broadband. The same four-way classification question, which routed a ticket to one of four categories, came back from Jev with a median of 313 milliseconds against 1,712 milliseconds from a frontier model asked to reply with the category word and nothing else. Both got the answer right on every run, so this isn’t an accuracy story; it’s a time story- roughly a fifth of the latency. The routing gate I built, with nine officers and four questions in one call, has a median of 437 milliseconds across ten runs. And here’s the part that changed how I design with it: five decisions in a single request cost the same wall-clock time as one, 309 milliseconds against 313, because the questions run in parallel. The expensive part isn’t judgment; it’s the round trip. So ask everything you might want to know in one call instead of making four calls in sequence.</p><p>Cheaper is where I want to be precise, because the numbers are good and I’d rather you checked them than took my word. TypeSafe publishes Jev at $0.042 per million input tokens, with output tokens free, and their comparison table puts frontier models at $0.20 to $10 per million input, with output around five times the input rate. Both figures are on the vendor’s launch post and on OpenRouter’s listing for the model. Free output isn’t a discount; it’s structural: a model that doesn’t stream prose doesn’t bill you for prose. Run my routing-gate arithmetic, and the whole four-question call works out at $0.00003, which is roughly three cents per thousand routing decisions.</p><p>There’s a trade inside that, and you should know it before you plan around it. Jev used more input tokens than the language model did on the same task, 438 against 126, because my request has to define what it’s choosing between. It wins on tokens entirely on the output side, and it wins hard: 47 output tokens covering the choice plus a probability for all four options, versus somewhere between 90 and 316 for a single word. If you cap a reasoning model’s output budget tightly, you don’t get a shorter answer; you get no answer after the same wait. I measured that too, and it’s the reason I stopped using tight output caps on models that think before they reply.</p><h3>Where It Doesn’t Behave the Way You’d Hope</h3><p>Three things, honestly.</p><p>The criteria shapes differ between the question types, and the error you get doesn’t prepare you for it. A choice takes a map of option names to descriptions. A score takes an ordered list, lowest first. Send a map where a list belongs, and you get an HTTP 422 saying Input should be a valid list. The API is entirely clear about it afterwards. The lesson is mundane and worth repeating: when you install someone&#39;s skill, their README is the artefact, not the vendor&#39;s marketing site.</p><p>The model field is mandatory on every request, which I discovered the same way, with a 422 telling me Field required. An alias called latest feels like it ought to have a default. It doesn&#39;t.</p><p>The third one isn’t a mistake; it’s a property to design around. Scores wander between runs. I asked the same scoring question ten times across three different shapes of the same input and got positions between 1.51 and 1.71, with different probability distributions on each run. Two tenths of a level on a four-level scale is not noise you can ignore if your rule says “escalate anything above 1.57”. So I use a choice as a branch I trust, and a score as a ranking signal that orders a queue. Ordering survives a two-tenths wobble. A threshold doesn’t. If I do need a score to gate something, I put the boundary where the observed spread can’t reach it, or I combine several scores with weights in my own code, where the arithmetic is mine to see.</p><p>What I wouldn’t use it for is anything requiring an explanation. If you need to know why, Jev won’t tell you, and that’s the design, not a gap. It’ll tell you the answer is 0.94 and where the rest of the probability went. That&#39;s your code’s business.</p><h3>What To Do Next</h3><p>Start with one decision you currently get from a language model, then parse it. Pick something with a small set of possible answers, so you can write down the right answer for a few hundred inputs by hand and check the model against your own judgment before it touches anything that matters. The documentation’s own guidance is that thresholds belong on your data and your consequences, and that a probability is not permission to act. That reads like a disclaimer. It’s an instruction, and the variance I measured is why it exists.</p><p>Then ask the questions together. This is the cheapest win available and the least obvious. Four questions about one request cost the same round trip as one, so the sensible design is to ask everything you might want to know and let your code read the two answers it needs. That’s a different shape of code, not just a faster one.</p><p>Then take one decision away from a language model in production and route it through Jev instead, and measure the change on your own connection rather than trusting mine, because my 300 to 400 milliseconds is a network round trip and it’ll differ on your link. Keep the language model for language. It’s very good at that and expensive at everything else.</p><p>When you record what a decision engine returned, record the distribution as well as the verdict. An answer with no spread on it is an answer you can’t audit later, and the audit is the whole point of writing decisions down.</p><p>If you want the thing itself rather than a description, it’s in my public repository at <a href="https://github.com/ciberjohn/Hermes-Skills/tree/main/jev">github.com/ciberjohn/Hermes-Skills/tree/main/jev</a>: the packaged skill, the caller script, the routing gate I described above, the profile sync script, and the upstream drift checker, under MIT. It’s one of 17 skills in that repository, and every one of them is free.</p><h3>Sources</h3><ul><li><a href="https://docs.typesafe.ai/llms.txt">TypeSafe documentation index</a> — the starting point, and the way to find every page below it</li><li><a href="https://typesafe.ai/blog/introducing-system-one-models-and-jev">Introducing System One Models &amp; Jev</a> — the vendor’s launch post: what a System One model is, the wording about what it refuses to do, and the price and latency comparison table</li><li><a href="https://docs.typesafe.ai/concepts/system-one.md">System One</a> — the programming model</li><li><a href="https://docs.typesafe.ai/primitives.md">Primitives (Questions)</a> — the three question types and the fields each answer carries</li><li><a href="https://docs.typesafe.ai/primitives/choice.md">Choice</a> — the criteria-as-map shape and how the probabilities are returned</li><li><a href="https://docs.typesafe.ai/primitives/score.md">Score</a> — the ordered levels, and how the score and confidence are derived</li><li><a href="https://docs.typesafe.ai/confidence.md">Confidence</a> — confidence as a measure of how spread the distribution is</li><li><a href="https://openrouter.ai/typesafe/jev-1.13">Jev 1.13 on OpenRouter</a> — the independent listing for the model, including its published price and measured latency</li><li><a href="https://github.com/typesafe-ai/skills">typesafe-ai/skills</a> — the upstream MIT agent skill this packaging is built on</li><li><a href="https://github.com/ciberjohn/Hermes-Skills/tree/main/jev">ciberjohn/Hermes-Skills, the </a><a href="https://github.com/ciberjohn/Hermes-Skills/tree/main/jev">jev folder</a> — the packaged skill described here: the SKILL.md, the README with its copy-paste install prompt, the caller script, the routing gate, the profile-sync script, the upstream-drift checker and the checksum manifest. MIT, free to use and adapt</li><li><a href="https://github.com/ciberjohn/Hermes-Skills">Hermes-Skills</a> — the full public repository of 17 agent skills, of which the Jev packaging is one folder</li><li><a href="https://console.typesafe.ai/keys">TypeSafe console</a> — where the API key is minted</li><li><a href="https://research.eye.security/rise-of-the-jev-clones/">Eye Security, <em>Rise of the Jev-Clones</em></a> — the research on the lookalike shopfronts, including the mark-ups and their own caution that they found no illegality</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35c965b42c66" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My file manager kept crashing. I blamed the cloud. I was wrong.]]></title>
            <link>https://joaolealdasilva.medium.com/my-file-manager-kept-crashing-i-blamed-the-cloud-i-was-wrong-ef673b2baf8e?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef673b2baf8e</guid>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[kde]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[chromium]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 18:40:49 GMT</pubDate>
            <atom:updated>2026-09-28T18:45:04.284Z</atom:updated>
            <content:encoded><![CDATA[<p>Monday evening, after all-day waiting on medical exams and remoting into my home machine with a tablet, Dolphin (my Linux file manager) crashed. Konsole crashes. Ark crashes. Even the SSH password prompt crashes. Every KDE app on my laptop segfaulted within minutes on a machine that had been rock solid for a week.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B-rBohLabwPQ5o4xMS0Auw.png" /></figure><p>My first suspect was obvious: <strong>rclone</strong>. I have Google Drive and OneDrive mounted as FUSE filesystems, and the crashes seemed to happen while browsing them. So I spent hours on the mounts. Restarting them. Checking tokens. Reading journals.</p><h4>Still crashing.</h4><p>So I checked KWallet. Innocent.<br>Then the NVIDIA driver and the Wayland stack. Innocent.<br>Then a full font audit, and there it was: a “font file” in my fonts folder that turned out to be a GitHub 404 HTML page, saved with a .ttf name by a curl without -f. A corrupt file, right where the crash backtrace pointed (fontconfig). I removed it, rebuilt the caches, and the crashes stopped. Declared victory.</p><h4>Then I rebooted. The crashes came back.</h4><p>That reboot forced the real answer out. The backtrace was identical, but the crash was a use-after-free of cache data, not bad font data. And the fontconfig cache directory told the story: at login, someone had rewritten every cache file in a NEW format, format 12, with compatibility symlinks pointing the system’s format-9 readers at them.</p><p>The writer? <strong>Brave</strong>. It auto-updated to Chromium 154 that afternoon; the exact moment the storm began. Chromium 154 bundles its own, newer fontconfig, and on launch it writes its cache into the SHARED ~/.cache/fontconfig. My system fontconfig followed the symlink, accepted the file, and read a format-12 structure as format-9. Garbage in memory. SIGSEGV in every app that draws text. A known upstream regression, hours old, filed the same day.</p><p>The fix is a one-liner: run the browser with a private XDG_CACHE_HOME so its caches stay out of the shared directory. Verified, documented, done.</p><h4>Three lessons I’m keeping:</h4><p>1. When many unrelated apps crash the same way, read the coredump backtrace before anything else. coredumpctl debug &lt;app&gt; named the guilty library before the timeline did.</p><p>2. “Fixed” isn’t fixed until you’ve survived a reboot and can explain the mechanism. My first fix worked by coincidence: it flushed the poisoned cache files without touching what wrote them.</p><p>3. Ask what writes to shared state. The bug wasn’t in rclone, the driver, or any component I was testing. It was in the interaction between two fontconfigs over one cache directory.</p><p>(And yes, the corrupt “font” was real, and it’s still gone. Use curl -fL and verify downloads with `file`. But it was a red herring, and red herrings that arrive with plausible evidence are the dangerous ones.)</p><p>I&#39;ve written everything up as a gotcha in my machine rebuild repo, so future me never has to learn this twice.</p><p>And I am still waiting to be discharged from the hossy….</p><p>#Linux #KDE #Debugging #Chromium #OpenSource #Sysadmin #BuildInPublic</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef673b2baf8e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I tested pktz, an eBPF traffic monitor, and here is my honest, open review.]]></title>
            <link>https://joaolealdasilva.medium.com/i-tested-pktz-an-ebpf-traffic-monitor-and-here-is-my-honest-open-review-957c4c3b7519?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/957c4c3b7519</guid>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[ebpf]]></category>
            <category><![CDATA[network-monitoring]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Fri, 25 Sep 2026 14:58:04 GMT</pubDate>
            <atom:updated>2026-09-25T14:58:04.105Z</atom:updated>
            <content:encoded><![CDATA[<p>Something on my machine pulled 46 megabytes from PyPI while I was writing a throwaway shell loop, and the only reason I know about it is that a network monitor happened to be running at the time.</p><p>The loop was five URLs: a GitHub project page, the GitHub API, https://pypi.org/simple/, debian.org, and Cloudflare&#39;s trace endpoint. Four of those return small pages, the largest of them around 300 KB. The fifth is the entire Python package index as a single HTML page, and it is 46,387,713 bytes. I confirmed that with curl&#39;s own size_download counter afterwards, because my first instinct was to blame the monitor.</p><p>That is the use case for pktz, a small Go tool that shows network traffic per process and per connection on a live machine. It is not the first tool to do it, and it will not be the last, but &quot;which application is eating my uplink&quot; is a question most of us answer with guesswork: a traffic graph that shows an address and no process name, or a packet capture we then correlate by hand.</p><p>This piece is what I found when I installed it and then tried to break its numbers: how it gets its data, what happens when the two documented install paths give you different code, how accurate the accounting really is against transfers whose size I knew to the byte, and the blind spot that the README does not mention.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AgVXbnguRTxWXDTtdr9KjA.png" /></figure><h3>What pktz actually is</h3><p>The repository description is blunt: “eBPF-powered network traffic monitor, per process, per connection, live”. It is MIT licensed, written in Go, and was created in April 2026. As of this week, it has 270 stars, 19 forks, one open issue, and one contributor with 70 commits. The next largest contributor has one.</p><p>In the wider ecosystem, it sits in a modest field. A GitHub search for eBPF network traffic monitors returns 36 repositories. ntopng has 8,205 stars, picosnitch has 1,000, and pktz is third at 270. The discussion around it is thin, which is worth knowing before you judge it by the number of stars. This is a single-maintainer project with a clear idea, not a product with a roadmap meeting.</p><p>The architectural claim in the README is worth quoting precisely, because the maintainer corrected it himself in a later commit. The original text said “Built on eBPF, so it hooks straight into the kernel. No polling /proc. No sampling.&quot; That is now: &quot;Built on eBPF for traffic accounting, with /proc used to map sockets back to processes. No packet sampling.&quot;</p><p>That correction is important, and honest. Reading the code, the split matches the new wording exactly. Traffic accounting is eBPF: kprobes on tcp_sendmsg, tcp_cleanup_rbuf, udp_sendmsg and skb_consume_udp, with each call adding its byte count to per-connection and per-process counters. There is no sampling anywhere, and no periodic read of interface counters pretending to be per-process attribution. But the mapping from a socket to the process that owns it is a /proc scan: the collector walks /proc/net/tcp, /proc/net/udp and the rest resolves the socket inode and finds the owning PID by reading /proc/&lt;pid&gt;/fd. The two halves are joined every 300 milliseconds, which is why the display is a snapshot rather than a stream. Remember that interval, because it produces the one real limitation I measured.</p><p>The collector keeps four eBPF maps: connection stats (10,240 entries), process stats (4,096), a socket-to-PID map used for retransmission attribution, and a 1 MB ring buffer for DNS events. Optional GeoIP databases add country flags and ASN names, downloaded from DB-IP under CC BY 4.0 with no account, and they are the difference between a bare address and a flag with CLOUDFLARE next to it.</p><h3>Two install paths, and they disagree</h3><p>The README offers three ways in. I tried two of them, and they hand you <strong>different</strong> software.</p><p>The first is a pre-built binary. The command is the usual one-liner, and it works:</p><pre>$ curl -Lo pktz https://github.com/immanuwell/pktz/releases/latest/download/pktz-linux-amd64<br>$ ./pktz --version<br>pktz 0.1.0</pre><p>The release you just downloaded is tagged 0.3.0 and was published on 23 April 2026. The binary that arrived says it is 0.1.0. That is not a download problem: the version constant in main.go is still 0.1.0 in the source tree at the 0.3.0 tag, so every release built from it reports the same thing. It is cosmetic, and it is exactly the kind of cosmetic problem that costs someone several minutes during an incident when they are trying to work out which build is on which host.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*Yuy5xvS0MCs26bmMawUK5w.png" /></figure><p>The second path is Go’s own installer: go install github.com/immanuwell/pktz@latest. On the surface, this is the cleaner option because the eBPF objects are vendored into the module, and you don&#39;t need clang, libbpf, or bpftool. It just fetches and compiles. The catch is subtler than the version string.</p><p>Go’s module proxy does not accept a version tag unless it starts with v. This project&#39;s tags are 0.1.0, 0.2.0 and 0.3.0, with no prefix. Ask the proxy for the version list, and it returns nothing. Ask for @latest and it falls back to the default branch, which it records as a pseudo-version:</p><pre>{&quot;Version&quot;:&quot;v0.0.0-20260825161428-e580e7e33396&quot;,&quot;Time&quot;:&quot;2026-08-25T16:14:28Z&quot;}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*XtkRGHmIfptWVH1XbunRLw.png" /></figure><p>So the two install paths do not deliver the same program. The binary gets you the April tag. go install gets you the August HEAD. The difference is not trivial: git diff --stat 0.3.0 HEAD reports 1,052 insertions across 18 files, including an entire DNS history collector of 365 lines, a fourth detail pane to display it, a test suite for the sort keys, and a CI workflow. The README at HEAD describes the DNS pane. The published binary has four panes and none of them is DNS, because it was built before that code existed.</p><p>None of this is hard to fix. A v prefix on the tags and a version string bumped at release time would do it. Until then, the README&#39;s feature list describes the default branch, and the download link describes April.</p><h3>What it looks like when it runs</h3><p>It needs root for the same reasons iotop and tcpdump do: loading eBPF programs and reading /proc/&lt;pid&gt;/fd for every process on the box. There is a setcap recipe in the README if you would rather not type sudo, with an honest warning attached: <strong>without root you cannot inspect file descriptors owned by other users, so the process list is less complete</strong>.</p><p>The main view is a process table with live receive and transmit rates, totals, connection counts, packet rates and a loss column, sortable on any of them. I took the screenshots for this piece inside a throwaway network namespace on the test host, driving real transfers through it, so the numbers on screen are real measurements and the two curl processes in the list were the only things talking.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-SHxGnwSotIhflts_EJfIg.png" /></figure><p>[the process view filtered to curl: two transfers running at 3.7 MB/s and 1.4 MB/s, with 55.3 MB and 24.0 MB received so far]</p><p>Pressing Enter on a process opens its connection details: local address and port, remote address resolved to a hostname, GeoIP country flag and ASN, protocol and state, plus a five-minute graph of receive, transmit and packet rates that follows whichever process your cursor is on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bzPRUBcgH0W5jitjHhrFyA.png" /></figure><p>[one connection to a French test mirror, 70.6 MB received in total, with the live rate graph underneath]</p><p>The detail view cycles through four panes with h and l. The one I did not expect to use is the tcpdump pane, which prints live packet lines for the selected process without leaving the interface.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wuCbfMBI13R7l2uV0MlS1w.png" /></figure><p>[ live tcpdump output filtered to the selected process]</p><p>There is also a container view that aggregates traffic by container or host and jumps back to the process view with c. That feature will decide whether this is useful on a modern box, because on a host running a dozen containers, &quot;which process&quot; is usually the wrong question. The right one is &quot;which container&quot;, and the process list alone answers it badly.</p><p>Two more things are worth knowing about. --log skips the interface entirely and emits newline-delimited JSON every 500 milliseconds, which means you can pipe it into jq, grep, or a rate threshold and forget about it:</p><pre>{&quot;type&quot;:&quot;process&quot;,&quot;ts&quot;:&quot;2026-09-24T21:29:40.047954851Z&quot;,&quot;pid&quot;:1416946,&quot;comm&quot;:&quot;curl&quot;,&quot;rx_bps&quot;:2410295.97411832,&quot;tx_bps&quot;:0,&quot;rx_bytes&quot;:2278110,&quot;tx_bytes&quot;:799,&quot;conns&quot;:1}</pre><p>And --metrics :9090 starts a Prometheus endpoint alongside whatever else you asked for. I scraped it live and got HTTP 200 with text/plain; version=0.0.4, 215 samples, and exactly the five metric families the README documents: pktz_process_rx_bytes_per_second, pktz_process_tx_bytes_per_second, pktz_process_rx_bytes_total, pktz_process_tx_bytes_total and pktz_process_connections, each labelled with pid and comm. Documentation matching reality is a low bar that plenty of tools miss.</p><h3>I checked its arithmetic (with AI assistance)</h3><p>A monitoring tool that is confidently wrong is worse than no monitoring tool, so the interesting question is not whether pktz looks good on screen. It is whether the numbers are right.</p><p>I set up a harness: a script that transfers an exact number of bytes from known endpoints, keeps the process alive long enough to be observed, and records ground truth next to the PID. Alongside it, pktz in log mode captures every process record. Then a comparison pass that takes the peak receive total pktz reported for each PID and divides it by the bytes that actually moved.</p><p>ScenarioReal bytesPeak RX reportedCoverage10 MB download, process held open10,000,00010,021,269100.2%10 MB loopback transfer10,000,00010,000,000100.0%10 MB download in ~200 KB chunks10,000,00010,021,165100.2%5 MB download, process exits at once5,000,00000.0%</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/769/1*xnCw77hJFddaE8Brn_yt5w.png" /></figure><p>[the comparison harness output]</p><p>The 0.2% overshoot is not an error. It is protocol overhead: IP, TCP and TLS headers that curl’s size_download does not count and pktz does. The loopback row, where there is no TLS and the bytes are counted on both ends, matches exactly. For long-lived flows, this is accurate, and I say that having gone in expecting the opposite.</p><p>The fourth row matters.</p><h3>The blind spot</h3><p><strong>A process that starts, transfers five megabytes, and exits between two polls does not appear at all. It is simply not in the list, and in log mode no record is ever emitted for it.</strong></p><p>I ran that case five times, each with five megabytes, and got <strong>zero</strong> process records for all five PIDs. The bytes are in the kernel’s counters, because the eBPF probes fired, but the collector only reports processes that still exist in /proc when it polls, and the PID is gone long before the 300 millisecond scan comes round. Anything a build step, a cron job, a CI runner, or a short-lived container does in under a third of a second is invisible.</p><p>This is a consequence of the architecture, not a bug. It is also <strong>not mentioned</strong> in the README, which still ends its architecture paragraph with “Every byte, every process, no excuses.” The tooling disclaimer is doing a lot of work in that sentence. Every byte is accounted for in the kernel map; not every process survives long enough to be displayed.</p><p>In practice, this is straightforward. pktz <strong>is a live observer</strong>, so it is excellent at answering “what is using the network right now” and bad at answering “what used the network at 03:14 while I was asleep”. For the second question, you want the log stream running continuously, and you should know that even then, sub-poll processes slip through.</p><p>There is a second, smaller edge, and it is one the project has already written down against itself. Issue #5, opened by a visitor to the repository and still open when I looked: “sock_pid_map entries are never removed, which may break retransmit attribution over time”. Reading bpf/pktz.c confirms the mechanism. Every send and receive calls bpf_map_update_elem on that socket-to-PID map, and nothing ever deletes a key. It is a plain hash with 10,240 entries rather than an LRU, so once it fills, updates start failing, and retransmission counts can end up attached to a socket that belonged to something else. The fix is a deletion in the socket-close path, which makes this a &quot;will be fixed&quot; rather than a &quot;will be argued about&quot;.</p><h3>What would I actually use it for, after all?</h3><p>Three things, in the order I would reach for them.</p><p><strong>Incident triage </strong>on a box you are already logged into. The question “why is this host’s uplink saturated” currently takes a traffic graph, a guess about the address, and a socket listing to find the process behind it. pktz answers it in one screen, with the process name and the connection underneath it. That is a genuine improvement, and it&#39;s why the 46 MB PyPI discovery happened at all.</p><p><strong>A metrics source for a network dashboard</strong>. The Prometheus endpoint is per-process and labelled, so it can feed an alert on “any single process above 100 Mbit for five minutes” without installing anything heavier. It is not a replacement for node-level interface metrics, but it answers a question interface graphs cannot.</p><p><strong>Container attribution</strong>. The container view is the feature I would build the rest around, because the failure mode it addresses (one container saturating a host link) is the one I actually meet.</p><p>For everyone reading this who is not running servers: the useful translation is that your laptop already has this problem. Something on it uploads when you are not looking. A tool in this class helps you find which process it is, and if you are on a metered connection, that is worth knowing.</p><h3>The rough edges</h3><ul><li>The version string is wrong in every published binary, and the tags do not work with go install.</li><li>Short-lived processes are invisible, which the README does not say.</li><li>It needs root, or capabilities that give it most of root’s reach.</li><li>The eBPF objects ship pre-compiled, which is convenient and also means you are trusting a binary blob built against a specific header set. It worked on kernel 6.8 here; I did not test anything older or newer.</li><li>The interface is a terminal UI with mouse support and thirteen keybindings. If you live in a terminal you will be at home in thirty seconds. If you do not, --log is your interface.</li><li>One maintainer, a month without a commit, and an open issue about a map that never gets cleaned. <strong>Judge that honestly rather than reading the star count as a support contract.</strong></li></ul><h3>The KeyPoint</h3><p>pktz does the hard part right. The accounting is unsampled and measurable, the per-connection detail is genuinely useful, the Prometheus endpoint matches its documentation, and when I tried to catch it lying about a ten-megabyte download, it was accurate to within protocol overhead. Its weakness is the boundary of what a 300 millisecond snapshot can see, and its rough edges are the ordinary ones of a young single-maintainer project: version hygiene, a README that has run slightly ahead of the release, and one known leak in a kernel map.</p><p>If you want a per-process answer to “what is using this network right now”, <strong>install the release binary </strong>rather than the Go module, and keep the log stream running if you care about anything that finishes quickly. And read the --demo flag before your next screen share: it maps every real IP to a stable fake one and invents a plausible hostname to match. That is a thoughtful feature, and it is the one I would not have thought to ask for.</p><p>There is a habit here worth copying rather than a download. Before you trust any monitor, hand it a transfer you can count: pick a payload of known size, keep the process alive, and compare the totals. It is an hour of work; it is the only reason I can state the limits above with numbers instead of adjectives, and it works the same way against whatever tool you are using this week.</p><p>João Silva — <em>Strategic Technology Leader, AI &amp; Platform Engineering</em></p><h3>Sources</h3><ul><li><a href="https://github.com/immanuwell/pktz">pktz repository</a> — the subject: MIT licensed, Go, per-process eBPF traffic accounting with /proc socket-to-process mapping.</li><li><a href="https://github.com/immanuwell/pktz/releases">pktz releases</a> — three releases between 21 and 23 April 2026, tagged without a v prefix.</li><li><a href="https://github.com/immanuwell/pktz/issues/5">pktz issue #5</a> — the open report that sock_pid_map entries are never removed.</li><li><a href="https://proxy.golang.org/github.com/immanuwell/pktz/@latest">Go module proxy, </a><a href="https://proxy.golang.org/github.com/immanuwell/pktz/@latest">@latest for pktz</a> — shows the pseudo-version the install path actually resolves to.</li><li><a href="https://www.db-ip.com/">DB-IP</a> — the GeoLite country and ASN databases the --download-geoip-db flag fetches, CC BY 4.0.</li><li><a href="https://prometheus.io/docs/instrumenting/exposition_formats/">Prometheus exposition formats</a> — the text format the metrics endpoint emits.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=957c4c3b7519" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The £100 Button Box, and the Free Alternative I Built Instead]]></title>
            <link>https://joaolealdasilva.medium.com/the-100-button-box-and-the-free-alternative-i-built-instead-22d90866aa4a?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/22d90866aa4a</guid>
            <category><![CDATA[live-streaming]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[obs-studio]]></category>
            <category><![CDATA[streaming]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 17:55:32 GMT</pubDate>
            <atom:updated>2026-09-18T17:55:32.590Z</atom:updated>
            <content:encoded><![CDATA[<p>The most expensive thing on a streamer’s desk is frequently not the camera, the microphone, or the capture card. It is a grid of buttons. The Stream Deck is a small piece of hardware that switches scenes in OBS, toggles mute, and runs a few commands you could just as well run with a keyboard shortcut you have already forgotten. The hardware is lovely. The price is a decision. I took a better option: I built the same thing as a free, open-source window called obs-board, and this article is about why that gap existed, how it works under the hood, and where it honestly falls short.</p><p>This article covers the market gap I identified that obs-board fills, why OBS already ships the protocol it needs, the security decisions that matter when software runs shell commands for you, and the trade-offs I want you to understand before you install it.</p><h3>The Button Box Market, and the Empty Square</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-sIFXzsrMMnJc8DIXoZ_MA.png" /></figure><p>Let us be precise about the market, because the numbers matter and they are easy to get wrong. Elgato’s UK store lists the Stream Deck Neo at £99.99 and the classic MK.2 at £149.99, with similar pricing. That is the hardware camp: physical, tactile, satisfying, and locked to Windows and macOS for the first-party experience. Then there is the subscription camp, led by Touch Portal, which removes the hardware but adds a recurring fee of roughly £13 a year and remains closed-source. And there is the open-source camp, which is smaller than you would expect: Bitfocus Companion has 2,251 stars but is built for broadcast environments with physical controllers, StreamController has 1,084 stars but is a Linux app for the Elgato Stream Deck (hardware again), and the Advanced Scene Switcher plugin has 1,528 stars but automates scenes rather than giving you a control surface.</p><p>Notice the empty square. Free, open source, cross-platform, no hardware, no subscription. Every incumbent misses at least one of those five boxes, and most miss two. The appetite for a software alternative is documented: “A year with the Elgato Stream Deck” drew 179 points on Hacker News, “Reverse Engineering the Stream Deck+” drew 175, and the comments read like a support group for people who bought a button box and then had to explain it to their partner.</p><p>obs-board sits in that empty square. It is a window, not a device. It is MIT-licensed, installs in one command on all three platforms, and the only things a streamer must already own are OBS (free, ubiquitous) and a computer (they are streaming, so they own one). I released v1.0.0 on 30 June 2026 with eleven release assets: a .deb for Debian-family Linux, an AppImage for the rest, two disk images for macOS (Apple Silicon and Intel), a Windows installer, and update manifests for all three.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/641/0*xDw9FQF6d8JqNRbK.png" /></figure><p><em>The v1.0.0 release page: eleven uploaded assets covering Linux, macOS and Windows, plus the two source archives GitHub adds by itself.</em></p><h3>A Window, Not a Device</h3><p>The design bet of obs-board is that a macro pad doesn’t need to be something you can hold. It needs to be always there: a frameless, always-on-top, resizable window with adjustable opacity. The whole application is a grid of buttons organised into pages, with a configurable grid size from 2×1 up to 6×5, so a streamer can have a Gaming page, a Music page, and a Work page and switch between them with a click.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HsRO14h3hLl_ZSEZ.png" /></figure><p><em>A fresh pad, straight after install: page tabs along the top, empty slots waiting to take buttons, and the OBS connection settings in the panel beside them.</em></p><p>Each button has three tabs in its editor: Appearance (label, emoji icon, background and text colour), Action (what the button does), and Position (where it lives in the grid). The action types cover the verbs a streamer actually uses:</p><ul><li>OBS: Switch Scene switches to a named scene immediately.</li><li>OBS: Toggle Mute toggles mute on a specific audio input.</li><li>OBS: Start/Stop Stream and OBS: Start/Stop Recording control the stream itself.</li><li>Run Command executes a shell command, with per-OS overrides so the same button can run pactl on Linux and the Windows equivalent.</li><li>Open Program, Open Folder, and Open URL launch apps, directories, and links in the default browser.</li></ul><p>Under the hood, it is an Electron application, which I will properly defend in a moment, using React 18 with MUI for the Material look, Zustand for state management, and electron-updater to check GitHub Releases in the background and offer a one-click update. The whole config is a JSON file: export it, keep it in Dropbox or Git, import it on the next machine, and the pad comes with you. That portability is something hardware cannot match, because moving your Stream Deck setup to a new machine means rebuilding it by hand, while moving OBS-board setups is one file.</p><h3>A Setup You Can Actually Picture</h3><p>Let me make this concrete, because a grid of buttons is an abstraction until someone shows you what the buttons do. Consider a weekend streamer with three scenes in OBS: a camera scene for talking, a gameplay scene, and a “brb” scene with a timer for when the coffee calls. Page one of the pad has the three scene buttons, and because a streamer’s hands are busy, it also has mute toggles for the microphone and desktop audio, plus start and stop buttons for streaming and recording. The buttons are labelled with emoji, which sounds frivolous until you are live and looking for a red circle in your peripheral vision at 23:00.</p><p>Page two is where the window stops being an OBS remote and starts being a macro pad. One button runs a shell command to reset the audio devices because audio glitches are the streamer’s version of an on-call pager. Another opens the folder where the recording lands, because the post-stream ritual is copy the file, rename it, upload it, and every click saved is a click of faff avoided. Another opens the streaming dashboard in the default browser, and it works identically on Linux, macOS, and Windows because the button editor defines the command per platform. That per-OS override is the small feature that makes cross-platform honest: the same button, three commands, zero reconfiguration when the pad moves between a Linux desktop and a Windows laptop.</p><p>The pages themselves are cheap. Click the plus next to the page tabs, add a Music page with a couple of scene switches and a volume toggle, add a Work page for the recording workflow, rename the tabs, delete the ones that were a good idea at 02:00. The grid size is per page, so the camera page can be a tight 2×2 while the macro page sprawls at 4×3, and the settings panel tunes the accent colour, button corner radius, and opacity until the pad looks like part of the desktop instead of a widget that escaped from 1998.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LwuS5OuSsiOBLq6O.png" /></figure><p><em>The button editor: Appearance, Action and Position, with a live preview, over a pad that already carries a Main page and a second one for everything else.</em></p><h3>OBS Already Speaks the Protocol</h3><p>The most important fact in this whole story is that OBS doesn’t need a plugin to be controlled remotely, and hasn’t needed one since 1 September 2022. OBS Studio 28.0.0 shipped the OBS WebSocket server built in, so every modern OBS install is a controllable automation endpoint out of the box. The current release is OBS Studio 32.2.1 from 24 July 2026; the project has 74,950 stars on GitHub and roughly 99.7 million tracked downloads of its release assets, and it releases at an average cadence of 18 days. The platform obs-board automates is demonstrably thriving, and the protocol has been there for four years.</p><p>The WebSocket server defaults to port 4455 and authenticates via a challenge-response handshake: the server sends a challenge in the Hello message, the client computes a SHA-256-based authentication string, and a failed handshake closes the connection. obs-board uses the community-maintained obs-websocket-js client (MIT-licensed, 768 stars) and the request types it sends are all present in the v5 protocol specification: SetCurrentProgramScene for scene switching, ToggleInputMute for muting, StartStream and StopStream, StartRecord and StopRecord. That is the whole control surface OBS exposes over the wire, and it has been enough for every streamer I have talked to.</p><p>The setup is deliberately boring: enable the WebSocket server in Tools → WebSocket Server Settings, note the port, set a password (OBS generates one for you), and enter the host, port, and password in obs-board’s OBS settings. The chip in the title bar turns green when the connection succeeds, and the settings panel includes an auto-connect toggle so the pad starts talking to OBS on launch.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n1DwL_tggxIEuFzy.png" /></figure><p><em>The OBS half of the handshake: Tools → WebSocket Server Settings, the default port 4455, and authentication on with the password masked.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/344/0*4oUWEizUhHN15MNI.png" /></figure><p><em>The obs-board half: host, port and password, and a green confirmation once the two are talking.</em></p><h3>The Security Paragraph, Because This Tool Runs Commands</h3><p>obs-board runs shell commands on your machine by design, so the security model isn’t a footnote; it is the feature. Three controls matter most. First, the renderer runs sandboxed: sandbox: true, nodeIntegration: false, contextIsolation: true, so the web content that draws the buttons has no direct access to Node.js or Electron APIs, and all OS interactions go through a validated IPC surface in the main process. Second, every IPC handler validates its inputs before use: config keys are checked against an explicit allowlist, macro action types against a list of valid types, the OBS host against an RFC-1123 hostname regex, and opened URLs are forced to the http and https schemes, so no file:// or javascript: tricks. Third, importing a config file that contains shell-command buttons triggers a mandatory review dialogue that lists every command across all three platforms before anything is written to disk, and the auto-connect flag is force-set to false on every import so a crafted &quot;starter pack&quot; cannot silently point the pad at a rogue OBS server.</p><p>One caveat belongs in this article because it is real. The OBS WebSocket server binds to all interfaces by default, as confirmed in the OBS source code and reported in obs-websocket issue #907. The practical consequence: with the WebSocket server enabled and no password, any device on the same network can switch your scenes, mute your inputs, and start or stop your stream. localhost is safe by default; a remote OBS machine must be protected by a password and, ideally, a firewall rule. obs-board’s README says exactly this, and the article is the right place to repeat it, because the tools we add to our setups are only as secure as the defaults we do not change.</p><h3>The Honest Trade-Offs</h3><p>Now the parts I am not going to dress up. The first is Electron. The bloat debate is alive and well: “Why is Claude an Electron app?” drew 428 points on Hacker News in February 2026, and a macOS lag thread drew 302 in September 2025. I am not going to claim Electron is a performance marvel, because it isn’t, and a macro pad doesn’t need to be. It needs to render a grid of buttons, hold one WebSocket open, and behave identically on Windows, macOS, and Linux, and Electron is the pragmatic default for exactly that job. React provides a component-based UI, MUI provides a Material look without requiring a design system, and a single codebase ships to three platforms. Tauri would give a smaller binary and lower memory by using the system webview with a Rust backend, at the cost of a Rust toolchain and behaviour that can differ across each OS’s webview. For a tool whose entire job is a floating grid of buttons, that is a defensible trade, and obs-board pins Electron 42, which sits within the currently supported window (Electron supports the latest three major versions: 41, 42, 43 as of this writing).</p><p>The second honest trade-off is that a window is not a physical button under your thumb. Hardware has tactile feedback, a fixed place on the desk, and no chance of being covered by another window, and I am not going to pretend otherwise. What a window has is flexibility: per-page grids of any size, per-OS command overrides, opacity control, and updates delivered as downloads instead of new purchases. For some streamers, the physical device is worth £99.99, and that is a legitimate choice. For everyone else, the software pad exists.</p><p>The third honest point is the least flattering: the repository at the time I wrote this article had one star, the v1.0.0 release had been downloaded five times, and the Windows installer will show a SmartScreen warning because the binaries are not yet code-signed. That is the reality of a project that is a few weeks old, and I am including it because a reader who discovers it anyway deserves the truth up front. The README’s own comparison table says it plainly: free versus £149-plus hardware versus £13 a year, and I corrected the hardware figure to the actual £99.99 entry price while writing this, because a number a reader can disprove in five seconds is worse than no number at all.</p><h3>What to Do</h3><p>If any of this sounds useful, the path is short. Linux and macOS: curl -fsSL https://raw.githubusercontent.com/ciberjohn/obs-board/master/scripts/install.sh | bash. Windows, from an Administrator PowerShell: irm https://raw.githubusercontent.com/ciberjohn/obs-board/master/scripts/install.ps1 | iex. Or download the installer for your platform from the Releases page. Enable the WebSocket server in OBS with a password, enter the host, port, and password in obs-board, and you have a macro pad that costs nothing, requires no hardware, and follows you between machines as a single JSON file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*Fy4VvX4pJST9ED0_.png" /></figure><p><em>The Windows installer: one click to a working pad. Expect SmartScreen to ask you a question first.</em></p><p>If you are a developer, the repository is open under the MIT licence, the code style is plain ES modules with functional React components and no TypeScript, and the security policy in SECURITY.md explains the threat model and where to report a vulnerability privately. <strong>The project was built in collaboration with Claude as an AI pair programmer</strong>, from architecture and security hardening to the installer scripts, which is a story of its own, but the honest version is that an AI accelerates a developer; it does not replace one: the security review, the threat model, and the decision to sandbox the renderer were all judgements a human had to make.</p><p>The takeaway is simple. The streamer’s control problem is solved: hardware, sold on subscription, or ignored, and the empty square was free, open-source, cross-platform, with no hardware and no subscription. obs-board is that square; it’s stable enough to ship, and it costs the same as the air it runs on. If you stream, try it. If you know someone who streams, send them this. And if the SmartScreen warning makes you hesitate, good: treat a tool that runs shell commands with suspicion until it earns trust, and the source is right there to read.</p><h3>Sources</h3><ul><li><a href="https://github.com/ciberjohn/obs-board">obs-board repository</a> — the subject itself: MIT licence, v1.0.0 release (30 June 2026), install scripts, SECURITY.md threat model, and the comparison table that started this article.</li><li><a href="https://www.elgato.com/uk/en/p/stream-deck-neo">Elgato UK store, Stream Deck Neo</a> — verified £99.99 GBP entry price via structured data, 13 August 2026.</li><li><a href="https://github.com/obsproject/obs-studio">OBS Studio repository</a> — 74,950 stars, GPL-2.0, current release 32.2.1.</li><li><a href="https://obs-versions.com/statistics">OBS Versions statistics</a> — 99,694,794 tracked downloads, 246 releases, 18.2-day average release interval.</li><li><a href="https://github.com/obsproject/obs-websocket">obs-websocket README</a> — authoritative statement that the WebSocket server is built into OBS Studio 28.0.0 and above, default port 4455.</li><li><a href="https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md">obs-websocket v5 protocol specification</a> — challenge-response authentication and every request name obs-board uses.</li><li><a href="https://github.com/obsproject/obs-websocket/issues/907">obs-websocket issue #907</a> — evidence that the server binds all interfaces by default and that bind-address control is an open request.</li><li><a href="https://releases.electronjs.org/releases.json">Electron releases feed</a> — current stable 43.4.0, v42 in the supported window.</li><li><a href="https://news.ycombinator.com/item?id=47104973">Hacker News: “Why is Claude an Electron app?”</a> — representative 2026 discussion of Electron’s cost/benefit, 428 points.</li><li><a href="https://github.com/bitfocus/companion">Bitfocus Companion</a> — 2,251 stars, broadcast control surface.</li><li><a href="https://github.com/StreamController/StreamController">StreamController</a> — 1,084 stars, GPL-3.0, Linux app for the Elgato Stream Deck.</li><li><a href="https://github.com/obs-websocket-community-projects/obs-websocket-js">obs-websocket-js</a> — 768 stars, MIT, the client library obs-board uses.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22d90866aa4a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Gave My AI a Memory. It Cost Me Almost Nothing]]></title>
            <link>https://joaolealdasilva.medium.com/i-gave-my-ai-a-memory-it-cost-me-almost-nothing-201d652037e2?source=rss-58a4c1491c11------2</link>
            <guid isPermaLink="false">https://medium.com/p/201d652037e2</guid>
            <category><![CDATA[hermes-agent]]></category>
            <category><![CDATA[agentic-ai-memory]]></category>
            <category><![CDATA[honcho]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Joao Silva]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 16:51:34 GMT</pubDate>
            <atom:updated>2026-08-31T16:51:34.878Z</atom:updated>
            <content:encoded><![CDATA[<p>My agent forgot things. Not in the way humans forget, with a wince and a vague sense of a half-remembered conversation; in the way software forgets, which is total, instant and unapologetic. Every new session started from the same small set of notes I had written for it, and everything we said to each other that was not in those notes was gone by the time the next session began. I had already built it a second brain, a notebook it could read on demand, and that solved the problem of deliberate storage. It did nothing for the problem of everything else.</p><p>This article is the story of the missing layer in between: a memory that belongs to the agent itself, one that reads every conversation, keeps what matters, and hands it back when it is needed. It covers what that memory is without the jargon, how it works under the bonnet, why running it cost me almost nothing, and the slightly strange fact that the whole thing was deployed through nothing more than a natural conversation with the agent that now benefits from it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TIDnq4Hj5nLk9yJH491X9w.png" /></figure><h3>The Memory My Agent Came With</h3><p>Out of the box, my agent has a memory. It is a small thing, a couple of text files that get injected into the start of every session, carrying the durable facts I care about: who I am, what I am working on, the quirks of the environment it runs in, the preferences I have learned to write down rather than repeat. It is the memory of a filing cabinet. It holds what I decided was worth keeping, and it holds it verbatim, forever, in the exact words I used when I filed it.</p><p>That works for a surprising amount of life. The agent knows my name without asking, knows which tools I trust, knows not to touch certain production directories. I have a running set of notes that has survived dozens of sessions and saved me from repeating myself hundreds of times. If the measure of memory is whether you stop having to say the same thing twice, the built-in version passes.</p><p>But it is static in a way that becomes obvious the moment you want more. The file knows what I wrote, not what happened. It has no idea what we discussed last Tuesday, what conclusion we reached about that incident, which of my machines still has the old kernel, whether I said the deployment had to happen before the weekend or after it. All of that lived in the conversation, and the conversation was thrown away at the end of the session. I could write those things into the notes file, and sometimes I did, but that turns the agent’s memory into a diary I have to keep, and I have never been good at keeping diaries.</p><p>The technical term for what I had was short-term memory with a clipboard. The agent could hold a conversation brilliantly, then forget it the moment the window closed. For a long time, I didn&#39;t mind, because I didn&#39;t expect better. Then I built the second brain, and the contrast started to bother me.</p><h3>The Second Brain I Already Built</h3><p>I wrote not long ago about building a second brain in Joplin, so I wouldn&#39;t pay for Obsidian Sync. The short version: Joplin is a free, open-source notebook that syncs across my devices through the Dropbox I already had, and my agent reads it every day through Joplin’s REST API. It files what I throw at it, answers questions from what I have written, and never once asked me for a subscription. That arrangement has been running quietly for weeks, and it is the most boring, reliable piece of my setup, which is precisely the compliment I mean it as.</p><p>The notebook solved the problem of deliberate storage. When I want to keep something, I save it, and the agent can find it, quote it, and reason over it. That is a genuine second brain, and it works.</p><p>What it is not is a memory of the agent’s own life. The notebook only knows what I put into it. It has no record of the hundreds of sessions where the agent did real work, made real decisions, fixed real things, and then forgot it all. I could tell the agent to write a summary of every session into the notebook, and there is a scheduled task that half does something like that, but a summary is not the same as a memory. A summary is a report someone chose to write. A memory is what remains when you choose nothing at all.</p><p>So there I was with two layers: the notes file, holding what I decided was true, and the notebook, holding what I decided to keep. Both of them depended on me deciding. Nothing remembered the conversations themselves, the messy middle where most of the actual understanding lives.</p><h3>The Missing Layer</h3><p>The layer I was missing sits underneath the agent, not alongside it. It watches every session as it happens, keeps every message, and then, in the background, does the work nobody wants to do: it reads the whole conversation and works out what mattered. It does not store everything and hope for the best; it distils. It notices that I mentioned my birthday twice and stores the date. It notices that the family prefers Friday dinners and files that as a preference rather than a one-off remark. It builds a picture of the people it talks to, the way a good colleague builds a picture of you over months of meetings.</p><p>And then, at the start of the next session, it hands the agent a briefing card: here is what you know about this person, here is what happened recently, here is what might be relevant today. The agent does not have to search for anything. The memory comes to it.</p><p>This is not a new idea in the abstract. Every serious system has some notion of state, and every agent framework has been bolting memory onto the side for years. What was missing for me was something that did the reasoning honestly: a memory layer that treats remembering as an active process, not a storage bucket. I went looking for one, and I found Honcho.</p><h3>What Honcho Is</h3><p>Honcho is an open-source memory layer for AI agents, built by a company called Plastic Labs. It is the sort of project that has been quietly accumulating stars on GitHub, close to seven thousand of them by the time I checked, and it is licensed under AGPL-3.0, which means you can read it, run it, and modify it, with the usual open-source conditions. It describes itself as a memory library for building stateful agents, which is accurate and also, I suspect, deliberately modest.</p><p>The mental model has three parts: peers, sessions, and conclusions.</p><p>A peer is an entity that can talk: a person, an agent, a group. In my setup, the peers are me and the agents that work for me, which run, in a small piece of theatre I have never fully explained, as a Starfleet crew. A session is a conversation between peers, the thing that in my old setup was thrown away at the end. And a conclusion is the distilled output: a fact, a preference, a connection that the memory layer extracted from a session and decided was worth keeping.</p><p>The analogy that finally made it click for me is the personal assistant. You have meetings all week. You do not take minutes, because you are busy being in the meetings. Your assistant takes the minutes, reads them back, keeps a file on you, and before your next meeting hands you a card with the relevant history: who you are meeting, what you discussed last time, what you promised, what they care about. That is Honcho. The agent is you. The conversations are the meetings. The conclusions are the card.</p><p>What separates it from a notebook is that you don&#39;t have to tell it what to keep. It decides. Sometimes it decides wrong, and you can delete what it kept, but by default it pays attention. For someone like me, who has already admitted to being bad at diaries, that is the entire point.</p><h3>How It Works</h3><p>The light technical version, because you should know roughly what you are running before you run it.</p><p>Every message in a session is stored. That part is boring and cheap. The interesting part is what happens next, in the background: a worker process reads the conversation and asks a model to extract conclusions from it. Not a summary of the conversation, conclusions about the participants. In my very first <strong>test</strong>, three short messages produced nine of them: a severe peanut allergy, a birthday on 14 March, a preference for Friday dinners, the fact that the family car is a blue Renault Megane. The worker did not just find sentences; it understood that “anything with peanuts is out” means an allergy, and that a throwaway remark about a car is a fact about the household.</p><p>Those conclusions go into a Postgres database with vector search bolted on, which is the standard way to make semantic retrieval work: you can ask a question that was never asked before, and the database finds the conclusions that mean the same thing. I asked the system what car the family drives, and it returned the Megane, even though nobody had ever typed the word “car” into a search box.</p><p>The agent also gets the briefing card at the start of a session. The memory layer looks at who is talking, pulls the relevant conclusions and recent context, and injects them into the agent’s prompt before the conversation begins. The agent starts already knowing you. This is the part that feels like cheating the first time you see it, in the same way a good colleague who read your file before the meeting feels like cheating.</p><p>There is an honest friction section here, because every tool has one. The background worker batches its work, so memory does not form instantly: it waits until there is enough to say something worth saying, or a few minutes pass, whichever comes first. I tuned that window down for my traffic, because my conversations are small and I did not want to wait half an hour to see a memory appear. The default observation model is also self-centred: each peer remembers its own side of the conversation, and remembering what another peer knows about you takes configuration. And when I deleted my test conversations, the deletion was asynchronous, which is a polite way of saying I had to wait a moment and check the database to be sure the test facts were actually gone. A memory system that remembers <strong>test </strong>data is a memory system that lies, and I do not want mine lying.</p><h3>The Deployment That Was a Conversation</h3><p>Here is the part that still feels slightly circular, in a good way. The server I run my agents on has spare capacity. It is a modest machine, a few cores and a few gigabytes of memory with plenty left over, because agents are mostly idle and the heavy lifting happens elsewhere. When I decided Honcho was worth trying, the question wasn&#39;t whether to rent something new; it was whether the machine I already had could take on one more thing.</p><p>So I asked my agent, in the same natural conversation I use for everything else. I asked how feasible it would be to run this on the same box, and I asked it to work out the costs based on what we actually do in a week and a month. It went away, measured the machine, checked what the software actually required, pulled pricing for both the hosted and self-hosted options, and came back with a recommendation: self-host it; the marginal cost is near zero, and the privacy is better.</p><p>Then it deployed it. Four containers, all bound to the local machine, no ports exposed to the internet, no new credentials in the wild. It tested the whole loop end to end: wrote three messages, watched the background worker extract the nine conclusions, queried them back, and only then told me it was working. It wrote the documentation, including the parts where the default behaviour had surprised it. It updated the backup script so the new configuration would survive a disaster, ran the backup, and verified that the archive actually contained everything, including the secrets file. It pushed the configs to the private repository where all my fleet configuration lives, so I could rebuild the whole thing from the record alone.</p><p>The cost number is the one I keep coming back to. My entire fleet of agents, all the automation, all the scheduled jobs, all the conversations, runs on about two pounds a month of model API calls. That is not a rounding error in my budget; it is the whole bill. The memory layer added pennies to it. In a month, my agents have roughly 550 sessions and exchange on the order of ten and a half thousand messages, and remembering all of that, distilling it, and handing it back costs less than a coffee.</p><h3>The Test That Made It Real</h3><p>Deployments are easy to fake, and verification is hard to argue with. In one session, I told the agent an arbitrary fact about myself, deliberately boring, the kind of thing that would never make it into a notes file: that I prefer coffee over tea. I closed the session. I opened a completely fresh one, with no shared context, nothing carried over except the memory layer, and I asked it what my drink preference was.</p><p>It answered correctly, without searching, without hesitation. Coffee. It did not preface the answer with uncertainty or ask me to repeat myself. It knew, the way a person who has met you twice knows.</p><p>The second half of the test matters just as much. After I confirmed the memory worked, I deleted the test facts. Not because coffee over tea is a secret, but because I do not want my agent’s memory to be a pile of test data I forgot to clean up. A memory that cannot forget on request is a liability. So I deleted the test sessions, checked the database was actually empty, and let the next real conversation start the memory fresh. The system passed that test too: it forgot what I asked it to forget.</p><h3>What This Unlocks</h3><p>I now have three layers of memory, and they don&#39;t overlap as much as you might think. The notes file holds the durable facts I decided were true. The notebook holds the things I decided to keep. The new layer holds what actually happened: every conversation, distilled into conclusions and handed back at the start of every session. The filing cabinet, the library and the colleague who remembers.</p><p>The shift that matters is not technical; it is removing me from the loop. With the first two layers, I had to decide what was worth keeping. With the third, the system decides, and I can correct it. That is the difference between a diary and a memory, and it is why this one will actually survive contact with real life.</p><p>If you run an agent, you almost certainly already own the compute for this. You won&#39;t need a bigger server; you&#39;ll need a few hundred megabytes and a background process. The model calls are pennies at personal scale. The real cost is the ten minutes of setup, and if you are using an agent, you can probably convince the agent to do that part too. Mine documented its own upgrade, in its own voice, and the documentation is better than most of what I write after a deployment, which is either a compliment to it or an indictment of me.</p><p>My agents run as a Starfleet crew, which I mention only to explain the last thing I noticed. They have always had the ship, the bridge, the officers and the missions. What they did not have was a ship’s log that remembered what happened on the bridge. Now they do, and the next time we have a conversation, it will start with the memory of all the ones before it.</p><p>That is not a small thing. That is the difference between an agent you have to brief every morning and an agent you have worked with for years.</p><blockquote><em>João Silva aka the Real Ciberjohn— </em>Strategic Technology Leader, AI &amp; Platform Engineering</blockquote><h3>Sources</h3><ul><li>Honcho — <a href="https://github.com/plastic-labs/honcho">github.com/plastic-labs/honcho</a> — the open-source memory layer; “Memory library for building stateful agents”, ~7k stars, AGPL-3.0.</li><li>Honcho docs and pricing — <a href="https://honcho.dev/">honcho.dev</a> — managed pricing ($2.00/M context tokens with background reasoning included), self-host options, MCP and Hermes integrations.</li><li>I Built a Second Brain on Joplin So I Wouldn’t Pay for Obsidian Sync — <a href="https://joaolealdasilva.medium.com/i-built-a-second-brain-on-joplin-so-i-wouldnt-pay-for-obsidian-sync-c12286be9d1e">medium.com</a> — the earlier story about the notebook layer this article builds on.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=201d652037e2" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>