How Alessio Fanelli uses Open AI Symphony for Autonomous Coding and Pokémon Card Trading Workflows

In this episode of How I AI, I was so excited to sit down with Alessio Fanelli, the founder of Kernel Labs, a partner at Decibel Partners, and the co-host of one of my favorite podcasts, Latent Space. Alessio is one of those builders who is truly living in the future, and he shared a couple of workflows that perfectly illustrate the shift from simply prompting an AI to actually managing a team of autonomous agents.

We often hear people talk about orchestrating agents, but it's rare to see a practical, working system. Most people are still very much human-in-the-loop, guiding every step. Alessio, however, has moved past that. He's become an "agent manager," overseeing his AI workforce from his phone using standard project management tools. It’s a completely different way of thinking about productivity.

He walked us through two fascinating use cases that are worlds apart. First, he showed me his "software factory," an autonomous coding setup using OpenAI's Symphony, Linear, and a cloud server to handle his engineering tasks. Then, for something completely different, he demonstrated how he uses an AI agent to go shopping for underpriced, high-value Pokémon cards for his store, Merlin Games.

These workflows show the incredible range of what's possible when you stop thinking in terms of single prompts and start building persistent, automated systems. Let's get into how he does it.

Workflow 1: Building a "Software Factory" with OpenAI Symphony and Linear

Alessio's first workflow tackles a problem many of us in software face: managing the endless list of coding tasks, from new features to bug fixes. He used to run agents on his local machines, but found it clunky and hard to intervene or keep long-running tasks alive. His solution was to move everything to the cloud and become a manager, not a micromanager.

The Setup: Zoo, Symphony, and Linear

The core of his system consists of three parts:

• "Zoo": This is Alessio's name for his dedicated cloud VPS (Virtual Private Server). It's a beefy machine (32GB RAM, 4 cores) that's always on, running his agents.
• [OpenAI Symphony](https://github.com/openai/symphony): This is the open-source framework that acts as the conductor. It's an opinionated system for turning issues into code. It monitors a project board, assigns tasks to agents, and manages the entire development lifecycle.
• [Linear](https://linear.app/): This is the project management tool that serves as the main user interface. Instead of prompting an agent in a chat window, Alessio just creates and manages tasks in Linear, which Symphony then picks up.

The Step-by-Step Process

The workflow is elegant and follows a familiar software development lifecycle, just with AI agents doing the heavy lifting.

1. Task Creation: It all starts in Linear. Alessio creates a new issue with a simple, natural-language description of what he needs. For example, he created a task to clean up a UI table with the spec: clean up, pretty stable. let's remove the spread column too noisy. Let's also make the that name.
2. Kicking off the Work: He then moves the task from his backlog into the "To Do" column. This is the trigger. Symphony is constantly watching this column and immediately spins up an agent to handle the new task.
3. Planning and Execution: The agent first creates a workpad, which is a detailed plan outlining how it will tackle the task, including acceptance criteria and validation steps. It then gets to work, writing and modifying the code.
4. Human Review: Once the agent believes it has completed the task, it moves the Linear ticket to a "Human Review" column and opens a pull request (PR) in GitHub. This notifies Alessio that the work is ready for his review. He can look at the code changes and, importantly, see a live preview of the changes deployed on Vercel.
5. The Rework Loop: If the code isn't quite right, Alessio leaves comments directly on the GitHub PR, just as he would with a human developer. He then moves the Linear ticket to a "Rework" column. Symphony sees this, and the agent reads all of his feedback, creates a "rework checklist," addresses each comment line-by-line, and submits a new PR for review.
6. Completion: Once the PR is approved and merged, the agent moves the ticket to "Done." The whole process is managed asynchronously, allowing Alessio to assign tasks from anywhere, even his phone.

Tracking Costs and Improving the System

A brilliant part of Alessio's custom setup is his dashboard that tracks the token usage for every single task. He's found that most small-to-medium tasks cost between 15 and 60 million tokens. However, one massive refactoring task—making a locally-built app deployable on Vercel—cost a whopping 221 million tokens.

This ledger isn't just for accounting; it's a health metric for the workflow. If a task costs way more tokens than expected, it's a signal that the agent struggled. This usually means the initial instructions were unclear or the agent is missing a specific tool or skill it needs. This data helps him improve his workflow.md file—the core spec that tells Symphony how to operate—or build better tooling, like Glimpse, a Playwright extension his team at Kernel Labs built to allow agents to take screenshots and perform visual diffs.

Workflow 2: An AI Agent for Pokémon Card Arbitrage

The second workflow Alessio showed me is just as impressive but for a totally different reason. It highlights how AI can provide incredible leverage in small businesses, especially those dealing with messy, real-world data. Alessio owns a trading card store, Merlin Games, and uses AI to automate the incredibly tedious process of finding and pricing valuable cards.

The Challenge: Heterogeneous Data at Scale

The world of collectibles is filled with what he calls "heterogeneous data." Every card is different, listings are inconsistent, and prices fluctuate constantly. It's a nightmare to automate with traditional software. A human has to manually search eBay or TCGPlayer for a card, compare recent sales, and decide if a listing is a good deal. It's slow, inefficient, and limits how much business you can do.

This is where an LLM with browsing capabilities becomes a superpower. Alessio uses Codex to act as his autonomous purchasing agent.

The Step-by-Step Process

1. Gathering Intelligence: First, the agent needs a list of valuable cards to track. Many high-end cards are graded by a company called PSA, and each graded card has a unique certificate number. This data isn't available in a clean API. So, Alessio gives the agent a starting point and a goal:

fill out the certificate number for every card that costs more than a thousand dollars.

The agent then browses the web, finds images of these graded cards, and uses vision to extract the certificate numbers, building its database.

1. Hunting for Deals: With its target list, the agent's next job is to find underpriced listings. Alessio triggers this with another prompt that uses a custom skill he built:

use the eBay PSA premium. Let's find some underpriced cards from our premium list.

This skill contains the logic for how to search effectively, how to handle different grading companies (e.g., a PSA 9 might be equivalent to a BGS 10), and how to batch requests to avoid getting blocked by eBay.

1. Analysis and Reporting: The agent then autonomously navigates eBay, searching for the cards on its list. It scrapes the prices, compares them to the market data it has, and flags listings that are significantly underpriced. This turns hours of manual searching into an automated background task, allowing Alessio and his team to focus on making the final purchasing decisions.

This is my favorite kind of AI application. It doesn't replace a human, but it provides the leverage for a small business to compete at a much larger scale. It perfectly intersects the digital and physical worlds, solving an inventory problem that has plagued small business owners—from my dad's fish delivery business in Rome to my own project of cataloging the 600 books in my house!

Final Thoughts

Alessio's workflows are a powerful preview of where we're headed. The key takeaway is the shift from being an "agent prompter" to an "agent manager." The real leverage comes from building persistent, cloud-based systems where agents can work for you autonomously.

Whether it's a highly structured "software factory" managed via Linear or an arbitrage bot scouring eBay for Pokémon cards, the principle is the same: define the rules of engagement in a clear spec (your workflow.md), give the agent the right tools, and then let it run. By tracking performance metrics like token cost, you can create a feedback loop to continuously improve your AI workforce.

I encourage you to think about what parts of your own work could be systematized this way. What tedious, manual processes could you offload to an autonomous agent you manage?

It was an awesome conversation. A huge thank you to Alessio for coming on the show and sharing so much practical detail.

Episode Links

• YouTube: https://youtu.be/KtmaWUVdnx4
• Spotify: https://open.spotify.com/episode/6BinWqjJkC9Slq53nVNqeC
• Find Alessio on Twitter at @fanahoba and listen to his podcast, Latent Space. If you're in the Bay Area, check out his coworking space Kernel and his card store Merlin Games in San Carlos.