Our Blog

Human-in-the-Loop in a Multi-Agent Travel Planner

By Bimal Gharti Magar
October 22, 2026

In the previous post I turned the multi-agent travel planner into a real multi-turn conversation with SQLite persistence and per-conversation locking. Every follow-up ran through a router that picked which agents to re-invoke, and the plan lived in a right-pane view that refreshed with each turn.

That post ended with a working chat surface. This one is about the piece you need before handing it off to anyone else: a way for a human to approve the plan before it commits — and, just as importantly, the weak-model hardening that made it safe to run the pipeline on cheaper providers in the first place. The ops side of the story (Docker, nginx, Litestream, OpenTelemetry) is its own post coming next.

The source code is on GitHub.

What we will cover

• A short tour of the weak-model hardening that made cheaper providers usable — verdict-inversion bugs, tool-calling loops, and the philosophy shift they forced
• An approval gate that pauses the pipeline after Auditor and only lets Aggregator run once a human clicks Approve
• Reject-with-feedback that turns a rejection into a new Replan turn instead of a dead end
• Refresh recovery so a paused turn survives a tab-close, and the per-conversation …

Upgrading a Vue.js application from version 2 to 3 using carefully directed AI

By Kevin Campusano
October 15, 2026

I wouldn’t go as far as saying that AI coding agents have made all programming problems shallow. But one area where they do excel is in well-specified but tedious tasks like upgrading a codebase to work with newer versions of their underlying frameworks and libraries.

Recently we inherited a legacy Ruby on Rails web application that had its frontend written with Vue.js 2. We were tasked with modernizing the entire codebase, and the frontend was of course a big part of that work. Version 2 of Vue has long been deprecated, so we needed to upgrade it to version 3.

Recently, with the advent of AI coding agents, the level of effort required for such tasks has been greatly reduced. However, in order to maintain ownership, control, and a thorough understanding of the codebase, and ensure high internal and functional quality, we couldn’t simply throw the codebase to our agent and big-bang-prompt it: “Please upgrade this codebase to version 3 of Vue”.

Instead, we took a deliberate, carefully planned approach where we owned the design decisions and relied on the agent for most of the grunt work and subsequent troubleshooting. In this blog post I’ll explain how …

Announcing Youth Town Hall — a new civic platform

By Ben Ironside Goldstein
October 5, 2026

We’re proud to announce Youth Town Hall, a nonpartisan platform where political candidates can connect with constituents ages 18–35. Each town hall gives young adults a focused place to submit questions and watch candidates’ video responses—without ads, algorithmic feeds, or vitriolic commentary.

We developed Youth Town Hall with the people behind the Presidential Youth Debates, which organized debates among U.S. presidential candidates—including Bill Clinton, Bob Dole, George W. Bush, John Kerry, Ralph Nader, Barack Obama, and John McCain—from 1996 to 2012.

Those events invited young people to help shape the conversation rather than simply watch it: youth-submitted questions, informed by a broad network of civic, educational, and media partners, were put directly to presidential contenders. Youth Town Hall carries that basic idea forward in a format built for participation across distance and schedules.

Connecting young voters with candidates remains important, but today’s media environment often works against sustained attention. Much political outreach happens by text, email, and social media. These channels can reach many people, but their messages arrive amid countless other …

Migrating a web app from .NET Core 2.2 to .NET 10

By Juan Pablo Ventoso
September 8, 2026

.NET Core 2.2 reached end of life years ago, so applications running on this version no longer receive security patches or bug fixes. Considering those risks, we recently migrated a client’s production application from .NET Core 2.2 to .NET 10. The application consists of a Razor Pages web app, a Web API that communicates with their public website, and a unit / integration test project. We also decided to use Claude Code to assist with the process, which turned out to be a great tool for organizing the work.

Going from .NET Core 2.2 to .NET 10 is a big jump, so before making any changes we put together an assessment of the application dependencies, potential breaking changes, and estimated the work involved in each area. The assessment was useful as a starting point, but some of the estimates changed (mostly for the better!) once we started working through the actual code with Claude. The range of hours from the estimate was ~32–59 hours, with a realistic mid-range of ~45 hours. How many hours did it take in the end? Keep reading :).

A phased plan

First, we turned the assessment into a plan document, dividing the migration into twelve phases, each with its own scope and …

Creating custom dictionaries with the Forgery gem

By Kevin Campusano
August 28, 2026

When it comes to generating fake data for testing (or any other purpose), most Rails projects nowadays use the Faker gem. With a simple function call, you can generate a random name, email, telephone number, etc.

However, if you’re still using the Forgery gem, there’s a neat trick that it has up its sleeve that, even though Faker can also do it, I’d say it feels more natural with Forgery: creating custom dictionaries. That is, defining a custom list of values and having the gem use that list as its data source.

This might be useful when you want to generate random-ish data, but want to limit the possible values.

In this short and sweet blog post, I show you how.

First, we add the gem to our Gemfile:

gem "forgery", ">= 0.8.1"

Then, we run its generator:

bundle exec rails generate forgery

This generates a directory structure under lib which serves as the foundation for our customizations:

lib
└── forgery
    ├── dictionaries
    ├── extensions
    ├── forgeries
    └── formats

Under lib/forgery/dictionaries we will put a raw text file with the list of words that we want our custom dictionary to contain. Under lib/forgery/forgeries we will put …

Upgrading Rails 5 to Rails 8 with AI: What Broke After the Specs Went Green

By Edgar Mlowe
August 4, 2026

We moved our internal Timesheet app, a legacy Rails application, from Ruby 2.4.10 and Rails 5.0.1 to Ruby 3.3.6 and Rails 8.1.3, with AI assisting the work throughout. We did it as a fresh-app transplant: build a clean Rails 8 app, move the old code into it, and get it running. The backend RSpec suite went green. bin/rails zeitwerk:check eager-loaded the configured application code without complaint.

Then we brought up the real stack for the first time: a development server, a seeded database, the React frontend, a real browser. Every request behind login returned a 500. The calendar failed. Monthly totals crashed. The 18 Playwright end-to-end tests run against that same live stack, so they only went green after those failures were fixed. The green suite had not been wrong. It had been silent.

This post is about that gap. What broke in a direct Rails 5 to Rails 8 transplant, why a green suite missed it, and how we verified the application’s highest-risk workflows after the migration. The app tracks hours, billing, reports, users, roles, and permissions, so quiet wrong answers matter more than loud crashes.

Why a fresh-app transplant instead of an incremental upgrade

The …

Adding Conversations to a Multi-Agent Travel Planner

By Bimal Gharti Magar
July 17, 2026

Photo by Bimal Gharti Magar, 2026.

In a previous post, I walked through a multi-agent travel planner built on the Microsoft Agent Framework (MAF). It worked, but it was single-shot: one prompt produced one plan, and the conversation ended there. If you wanted to swap a city, trim a day, or ask a clarifying question, the only option was to write a new prompt from scratch.

This post is the follow-up. We will turn that one-shot pipeline into a real multi-turn conversation, while keeping the same five agents under the hood. Along the way we will look at how to feed chat history through a MAF workflow, how to avoid re-running the full pipeline on every follow-up, how to persist conversations to SQLite, and how to keep a single conversation from running two turns in parallel.

The source code is on GitHub.

What we will build

• A multi-turn conversation surface where each follow-up message refines the plan in place
• A small LLM router that decides which subset of agents needs to run for each turn
• SQLite-backed persistence so conversations survive process restarts
• A per-conversation async lock that returns 409 Conflict when two turns race
• A three-pane browser UI: conversation sidebar, chat, …

Interchange Redis Sessions

By Mark Johnson
June 16, 2026

Photo by Josh Ausborne, 2022.

Interchange¹ now supports storing user sessions in Redis², an in-memory data store, as a core feature of Interchange 5.12. Sessions are where Interchange keeps client state that makes a catalog operate as a continuous experience–the shopping cart, form values, login status, and other data that persist from one request to the next. How and where that state is stored have a direct impact on a busy catalog’s performance, and Redis gives developers a fast, purpose-built option that sits alongside the storage backends Interchange has always offered.

Session storage in Interchange

By default, Interchange writes each session to a file on disk, and it has long been able to store sessions in a relational database instead by way of Vend::SessionDB, configured with the SessionType DBI and SessionDB directives. The database approach is the natural choice once a catalog is served by more than one Interchange server, since every server needs to read and write the same pool of sessions.

Relational databases certainly can function in this capacity, but a high-traffic session table is not where they shine. Every page view reads, writes, and locks a session …