Hey Hummingbot community 👋

July was a big month: v2.16.0 just shipped with a brand-new CLI built for AI agents, the Agent Builders Cup hackathon opens August 1 with a $20,000 prize pool, and we're kicking it all off live on The Bot Pod Episode 13. Let's dive in.

🚀 Hummingbot v2.16.0 is here

Our latest release makes Hummingbot more agent-friendly than ever — a scriptable CLI, agent memory in Condor, new connectors and chains, and hardened wallet security across the stack. More on the two biggest additions below.

Highlights:

• 💻 New hbot CLI — A non-interactive command-line interface for running, controlling, and monitoring Hummingbot without the TUI. Compact Markdown output, stable exit codes, and --json support make it easy for AI agents and humans alike to drive Hummingbot from scripts, CI, and agent workflows — no MQTT broker required.

• 🔗 Robinhood Chain & Unichain — Gateway adds two new EVM chains, with Uniswap router, AMM, and CLMM wired up on Robinhood Chain mainnet using official deployment addresses.

• 🔌 New Gemini & Lambdaplex connectors — Spot connectors for Gemini, the regulated cryptocurrency exchange, and Lambdaplex, a Hedera-native onchain exchange with offchain matching.

• 🔀 New Solana routers — Titan, DFlow, and OKX DEX join Jupiter as Solana router connectors, with all transaction signing consolidated through a single chokepoint.

• 🦄 Uniswap v4 routing — Routing now includes v4 pools on supported chains (mainnet, Arbitrum, Base, Unichain, and more), picking whichever route prices best. Plus, Permit2 allowances no longer expire every 48 hours by default.

• 🧠 Condor agent memory & skills — Agents now support persistent user memory and reusable skill playbooks, exposed via MCP tools and a new /memory command. The web dashboard also gains a full model picker with an advisor that steers you toward local or free OpenRouter models.

• 📊 Interactive reports — Condor reports are now self-contained interactive HTML with filters, linked charts, drilldowns, searchable tables, and CSV export — viewable in the dashboard or offline.

• 🔒 Wallet security hardening — Gateway adds at-rest key encryption, loopback bind by default, opt-in API auth, and rate-limiting for network-reachable deployments, with auto-generated mTLS certificates from Hummingbot API.

👉 Read the full v2.16.0 release notes

💻 Run Hummingbot from the Command Line

The headline feature of v2.16.0 is hbot, a new non-interactive CLI for running, controlling, and monitoring Hummingbot, without needing to go through the interactive Python shell.

Every command emits compact Markdown output with stable exit codes, and run/observe support --json for machine-readable output. That means AI agents and humans alike can drive Hummingbot from scripts, CI pipelines, and agent workflows. Under the hood, it runs the same HummingbotApplication and TradingCore engine as the classic client through a headless host.

Building an agent for the Agent Builders Cup? hbot is your new best friend.

👉 Read the hbot CLI docs

🔌 New Connectors, Chains & Routers

v2.16.0 expands where you can trade across both CEXs and DEXs:

• ⚡ Gemini — Spot connector for the regulated cryptocurrency exchange, trading via the Gemini Fast API (WebSocket) and REST v1 API with limit/market orders, cancellation, balance tracking, and real-time order and trade updates. Thanks to community contributor erickuhn19!

• ⚡ Lambdaplex — Spot connector for the Hedera-native onchain exchange with an offchain matching engine and onchain settlement. Thanks to community contributor petioptrv!

• 🔗 Robinhood Chain & Unichain — Gateway adds two new EVM chains, with Uniswap router, AMM, and CLMM wired up on Robinhood Chain mainnet using official deployment addresses.

• 🔀 Titan, DFlow & OKX DEX — Three new Solana router connectors join Jupiter, with all Solana transaction signing consolidated through a single signing chokepoint.

🏆 Agent Builders Cup Hackathon — Build Window Opens August 1

The Agent Builders Cup is an agentic strategy hackathon run by Botcamp, our affiliated education company — and it's almost go time.

Build a Hummingbot V2 Controller or Condor Agent, apply to one of six exchange sponsor teams — Orca, Derive, Gate, XRPL, Bitget, and Meteora — and compete for a $20,000 total prize pool. Each sponsor selects two agents, and the finalists face off in a 48-hour live trading competition.

📅 Key dates:

• August 1–31 — Build window

• September — Judging

• October 1–2 — Livestreamed finals

• October 7 — Winners announced at our Token2049 side event in Singapore

👉 Register for the Agent Builders Cup — full schedule, rules, workshops, and team sponsors at botcamp.xyz/hackathons

🎙️ The Bot Pod Episode 13: Hackathon Kickoff

Don’t miss the official Agent Builders Cup kickoff on The Bot Pod on Friday, July 31! We'll walk through the hackathon format, the exchange sponsor teams, what makes a winning agent, and how to get started building — plus the latest across the Hummingbot ecosystem.

Bring your questions — this is the best place to get them answered before the build window opens.

Happy trading,
The Hummingbot Team

Get the newsletter · Join Discord · GitHub

Lately, we’ve been monitoring a sharp rise in automated bots scanning cloud servers for vulnerabilities. These bots probe for exposed API ports and attempt to exploit any they find — including setups where Gateway or Hummingbot API are reachable from the public internet.

To keep your funds and private keys safe, we’ve shipped Gateway v2.15.1, a security-only patch that removes unsafe wallet operations from the server side. We strongly recommend updating immediately — especially if you’re running on a cloud server.

Hummingbot API was updated at the same time to reflect these changes.

What this means for you:

Going forward, wallets must be imported using keys you generate externally — either via POST /wallet/add (Gateway) or POST /accounts/gateway/add-wallet (Hummingbot API). Safe wallet routes (viewing, adding hardware wallets, removing, setting default) are unchanged.

Action required:

• Update Gateway to v2.15.1

• Pull the latest main branch of Hummingbot API

⚠️ If your setup relies on the removed wallet operations, you’ll need to switch to importing wallets instead.

🔒 Pro tip: Secure your cloud setup with Tailscale

Running Hummingbot on a cloud server? Consider using Tailscale to access your instance without exposing it to the public internet. It creates a private network (”tailnet”) so only your devices can reach your Hummingbot API and Gateway — no open ports, no scanning bots.

We’ve put together a step-by-step guide:
🔗 https://hummingbot.org/blog/securing-condor-and-hummingbot-api-with-tailscale/

This is a strongly recommended update for all users, especially anyone running on cloud infrastructure. Stay safe out there! 🔒

Michael Feng

Co-founder, Hummingbot

Hey Hummingbot community 👋

Since our last newsletter, we’ve been pushing improvements to the new Condor AI harness and the underlying Hummingbot API code repos on an almost-daily basis. Now, you can schedule and send regular reports via Telegram, as described in the podcast episode below, and use Condor with OpenRouter and other model providers. Currently, we’re overhauling the agent framework design, giving them personalization and memory, and improving their ability to help you manage trading bots.

These Condor updates use the fresh, new v2.15.0 release, which we shipped yesterday. This release also includes a new connector to the Lighter perps DEX, which has been heavily requested by the community, along with fixes to Hyperliquid, position management in perpetual connectors, and other updates.

I wanted to highlight a fun experiment we’re conducting with GRVT: a team trading competition that anyone can join, along with a new episode of The Bod Pod, in which Fede describes how he found a vulnerability in Jupiter’s RFQ system and became a white-hat hacker for a day.

Finally, check out the new Hummingbot Reporting, a real-time dashboard of trading volume by exchange generated by active Hummingbot instances around the world.

Michael Feng
Co-founder, Hummingbot

🚀 Hummingbot v2.15.0 is here

Our latest release includes the oft-requested connector to Lighter, exchange improvements, and security and AI upgrades across the stack.

Highlights:

• ⚡ New Lighter connector — Spot and perpetual connectors for Lighter, a decentralized exchange built on a zero-knowledge rollup with CLOB order books and verifiable on-chain execution. Includes candles data feeds for both markets.

• Hyperliquid improvements — Foundation builder code support for mainnet order attribution, fixed spot candles, websocket timeout for connection stability, and a fix for stale perpetual positions after partial close.

• Perpetual connector updates — Better ONEWAY position hold management across backtesting and live trading, improved position mode setting flow, and a fix for initial positions initialization.

• 🔒 Tailscale security — Condor and Hummingbot API now support Tailscale, so you can reach order placement, balances, and bot control over a private tailnet instead of exposing port 8000 to the public internet.

• 🤖 OpenRouter support in Condor — Use OpenRouter as an LLM provider for /agent, with access to a large model catalog through a single API key — including free models at $0 pricing.

• 🔗 Chainstack RPC provider — Gateway adds Chainstack as a cross-chain RPC provider for Solana and EVM networks for lower latency and more reliable swap execution.

• 🌊 Gateway CLMM fixes — Inverted BUY price fix on Orca/Meteora, real Uniswap pool balances, an optional binCount param on pool-info for liquidity distribution, and extended Ethereum tx receipt polling.
  

  👉 Read the full v2.15.0 release notes

🎙️ New Podcast: The Jupiter RFQ Hack

The latest episode dives into the backstory behind a vulnerability in the JupiterZ RFQ system that our CTO Fede discovered and helped patch :

We also discuss tokenized equities — Backpack exchange now offers transferable tokenized shares (e.g., SpaceX) and show off the new Condor reports feature, custom scheduled reports which now you can schedule and deliver via Telegram.

📊 New Live Reporting Site

We’ve launched a brand-new reporting site at reporting.hummingbot.org — a real-time window into Hummingbot usage worldwide.

Since Jan 2025, Hummingbot instances have reported over $36B in aggregated trade volume across 300+ connectors from 100K+ instances. The dashboard tracks it all live:

• 📡 Live feed — Trade data collected by exchange, updating in real time as instances around the world report in.

• ⏱️ Minute-by-minute snapshots — Drill into per-minute activity (reports, instances, and volume), and click any snapshot to dig deeper.

• 📈 Headline metrics — Total trade volume, 24h volume, active instances, and active connectors at a glance.

👉 Explore the live dashboard

🏆 GRVT Team Trading League

GRVT is officially launching their Team Trading League — a team-based trading competition — and we’re putting together a powerhouse Hummingbot team.

This is a fantastic opportunity for our community to pool our trading volumes, collaborate on strategies, and climb the global leaderboard together.

• 📖 Learn more: GRVT Team Trading League details

• 🎟️ Join with our invite code: grvt.io/?ref=6ZUODT5

Form up, run your bots, and let’s climb the leaderboard with the Hummingbot community.

🎯 Register for the Agent Builders Cup Hackathon

The Agent Builders Cup is coming — a multi-round hackathon for builders creating trading agents on Hummingbot, culminating in the finals. Registration is open now.

👉 Register for the hackathon

Security Notice

Beware of scammers impersonating the Hummingbot Foundation:

• We NEVER DM you first

• We NEVER sell or airdrop HBOT tokens

• HBOT is only earned through completing bounties

• Report suspicious activity in our Discord #scam-reports channel

We’re back with Episode 9 of The Bot Pod! This week, Mike and Fede are eating their own cooking—they’ve started running Condor internally for QA and client market making—and they put it on display: deploying live PMM Mister bots with the new global take-profit / stop-loss, reading five-minute controller snapshots in real time, and using a Condor routine to reverse-engineer Hyperliquid’s HLP vault. Along the way: a hard-won lesson on slippage, a sober take on Worldcoin, an urgent reminder to lock down your server against AI-driven attacks, and the new F1-style Agent Builders Cup hackathon.

• Watch the full episode: YouTube

• Register for the hackathon: botcamp.xyz

• Install Condor: condor.hummingbot.org

Episode Highlights

0:00 Dogfooding Condor

The big news: the team is now using Condor internally—both to run their QA operations and to power a new market making effort for clients. The thesis for the episode is simple: by using their own product, they’ll make it better for everyone.

1:00 Market Discussion: Saylor Sells & “Is Crypto Dead?”

Michael Saylor sold Bitcoin for the first time, and Mike’s TradFi friends are texting him asking if crypto is dead. Both hosts read that as a contrarian buy signal—there are only 21 million Bitcoin, and fiat keeps getting printed.

“When all the people are asking ‘Is crypto dead?’, it’s probably the best signal to buy.” — Fede

3:00 HYPE, LP Mistakes & Buying at All-Time Highs

HYPE was the week’s outlier, ripping from ~58 to ~72. Both hosts had conviction early but fumbled the execution: Mike bought HYPE six months ago around the HIP-3 launch, then parked it in an Orca HYPE-SOL LP pool and watched it convert entirely to SOL. Fede did the same, then later flipped a small position from ~$40 to ~$70K-equivalent for a tidy $3K profit. The recurring lesson: conviction is cheap; clean execution is hard.

“I never like to buy things at the all-time high.” — Fede

10:00 The Worldcoin Identity Bet

A genuine disagreement. Fede is bullish on Worldcoin’s role in proving humanity—logins for dating apps where you can’t tell a human from an AI. Mike is skeptical: identity verification is a small market, Worldcoin has scanned roughly 1% of humans, and the token has historically traded like a Sam Altman–backed meme coin.

“I think the revenue potential for identity verification is pretty low. It’s not a big market.” — Mike

13:00 What’s New in Condor: Five-Minute Controller Snapshots

The week’s headline feature. Condor and Hummingbot API now store a snapshot of each running controller every five minutes—realized and unrealized P&L, volume traded, positions held, executor state, and any custom info the controller wants to surface (like its current signal). It’s the same mechanism behind the portfolio page, now applied to live bots, giving you the full progression of a bot’s performance instead of just a point-in-time picture. There’s also a new routine download feature and fixes across the executors page.

22:00 PMM Mister: Global Take-Profit & Stop-Loss

PMM Mister gains a global stop-loss and global take-profit on top of the per-executor ones. The idea: be more aggressive to generate more volume, then use the global thresholds to control inventory and reset back to zero. In between, the bot does a lot of market making; on a deviation, it stops and starts over—turning a continuous process into one with discrete, manageable outcomes.

23:00 PMM Mister vs. pmm_v1: Where to Start

Mike’s primer for newcomers. PMM Mister is the advanced controller: self-managing executors across many order levels, each with its own SL/TP, and a “position held” bucket that lets the bot hold inventory rather than dumping at a loss. Powerful, but complex—so beginners should start with pmm_v1, which replicates the classic pure market making strategy, then graduate up.

“If you’re totally new, start with a simple pmm_v1 controller. Once you’re comfortable, migrate to PMM Mister—that’s how you run things the way a professional market maker does.” — Mike

26:00 Deploying Two Controllers: 3% vs. 7% Exposure

Live demo: Fede deploys one bot (a single Docker container) running two BTC controllers in parallel—$1,000 each, one exposing 7% of quote around the mid-price, the other 3%. The 7% bot does roughly double the volume of the 3% bot, but also carries more inventory risk. Mike explains how the Hummingbot API spins up the container, runs the strategies, and begins reporting performance into the snapshot view.

34:00 Securing Your Server: Tailscale & the AI Bot Threat

The episode’s most important PSA. The team is seeing freshly deployed Hummingbot API servers get scanned by AI-driven bots within moments of going live. Condor’s install scripts now close all exposed ports and put the machine on a Tailscale private network, so only your own devices can reach it. Cloudflare One/Tunnels is a valid alternative, and a community tip flags Socket Firewall for supply-chain scanning. Guides are landing on the Hummingbot site and Condor docs shortly.

“The moment you create a server, there are AI-based bots trying to infiltrate it. Because of AI, the game has changed.” — Mike

40:00 Reading the Numbers: Volume & Basis-Point Take-Profits

Why does a bot with only ~$15 per side rack up hundreds of dollars in volume but pennies in P&L? Because the take-profit is set to one basis point (0.0001)—the bot fills, immediately books a sliver of profit, and goes again, hedging each fill the instant it lands. Widen the take-profit to three basis points and the P&L profile changes entirely. It’s a clean illustration of how PMM Mister generates turnover while keeping risk tightly bounded.

48:00 Editing a Running Bot’s Config on the Fly

Condor maintains two layers of config: the general config you author, and a live copy baked into the deployed bot. Fede edits the live bot’s min-base-percentage from 0.2 to 0.1 and saves—updating the running bot without a restart, and without touching the original. Controllers mark which fields are is_updatable, so unsafe changes (like the trading pair or connector) are silently ignored.

50:00 “How Do I Make Money?” — The Honest Answer

The question they get every single week, answered honestly. Markets are efficient; there’s no black box. Expect to break even or lose a little at first while you learn. Real edge comes from a specific inefficiency—providing liquidity on a thin venue and hedging on a deep one, getting paid by a client to market make their token, or earning liquidity rewards. Hummingbot and Condor don’t print money; they make running that operation at scale dramatically easier.

54:00 Routines: Dissecting Hyperliquid’s HLP Vault

The standout demo. Using a Condor routine, Fede pulls Hyperliquid’s public API to x-ray the HLP vault: ~$349M TVL, ~1.35% APR, split into a losing “strategy A” and a profit-making liquidator “strategy B” that net out to roughly break-even. Because Hyperliquid lacks Binance-style hedge mode, the vault runs two inversely correlated strategies to hedge. Mike—a former HLP investor who exited because it was a black box—notes the vault is a big reason Hyperliquid launched with deep liquidity. Fede also debunks a viral claim (via hl.eco) that Hyperliquid has 3× Binance’s liquidity: he asked Condor, and it wasn’t true.

1:02:00 Why Routines Are Condor’s Best Feature

Mike’s verdict: routines are the most useful thing they’ve shipped in Condor. Each one is Python that can call any API and emit a portable HTML report—graphs, indicators, markdown—that you can email or send over Telegram. Reports can already be scheduled hourly or weekly; auto-delivery and a community routine hub are coming.

“Routines are the most useful feature we’ve added to Condor so far.” — Mike

1:04:00 XRPL, Rewards & the Exchange Land Grab

On a viewer question about XRPL’s low fees: it’s a key Hummingbot partner, and the XRP Liquid program is currently giving away 1,000 XRP per week to liquidity providers on pairs like XRP-RLUSD. Zooming out, Mike frames the broader land grab—Hyperliquid adding prediction markets, Polymarket and Kalshi adding perps—where every venue is converging on every market type, and Hummingbot’s job is to serve the traders, not the exchanges.

1:11:00 Condor Builders Cup: An F1-Style Trading Competition

Coming up: an F1-style trading competition. Each team picks two strategies; Botcamp’s slots go to the top demo-day strategies from Cohort 13—Raj’s tight, academically-grounded market maker and Wei Hong’s cross-exchange perp strategy. ~40 people have already registered. Builders get about a month to refine a strategy and apply to a sponsor team (each with its own criteria), then each winning agent gets $1,000 in capital to race over a 48-hour live competition. Register and stake your idea at botcamp.xyz.

“Each winning agent starts with $1,000 in capital and races during a 48-hour competition to see who wins.” — Mike

Next Week

The team keeps dogfooding Condor for their internal QA and client market making, with more fixes landing weekly. Watch for the Tailscale security guide on the Hummingbot site and Condor docs, and get registered for the Condor Builders Cup at botcamp.xyz before the build period opens. Join us live—possibly on a Wednesday next time—on YouTube.

Full Transcript

00:00:00 Intro: Dogfooding Condor

Mike: Hey everyone, I want to welcome everyone to the ninth episode of the Bot Pod podcast. I’m one of the co-maintainers, along with Fede, of the Hummingbot open source framework. Hey, Fede—where are you right now?

Fede: I’m in Italy, in Sardinia.

Mike: Nice. Fede’s still a millennial—he doesn’t have a mortgage and a kid like me—so he’s able to work from anywhere. He’s in Sardinia working there for the whole month.

We’re quite excited to do another episode. We’re recording on a Wednesday today, and it looks like we already have lots of folks live. Feel free to drop any questions about Hummingbot or Condor—we’re going to demo some new features that Fede has added to Condor in the last week.

We’re pretty excited because we’re actually starting to use Condor internally ourselves, to manage our internal QA operations as well as a new market making effort we’re starting for our clients. By dogfooding our own product, hopefully we can make it better for you guys as well.

But, like we always do, let’s start with a discussion about where the markets are. Unfortunately, it’s been a rough week.

00:01:00 Market Discussion: Saylor Sells & “Is Crypto Dead?”

Mike: I think because Michael Saylor sold Bitcoin for the first time, it’s caused some commotion in the markets. My friends in TradFi are asking me, “Is crypto dead?” But honestly, from my side, I actually look at it as a good time to possibly buy some Bitcoin. At the end of the day, there’s only 21 million Bitcoin, and we see new fiat currencies issued all the time.

If you believe in the value of a scarce financial asset—and I think Bitcoin’s already crossed a chasm into something that will be linear over time—times like this are a good time to acquire. Not financial advice, obviously, but in my opinion, if you believe in crypto, now is a good time to buy it.

Fede: Actually, for me it’s like, when all the people are asking, “Is crypto dead?”—based on your friends’ question, that type of person asking that—it’s probably the best signal to buy.

Mike: True. The one outlier in the downturn, though, has been HYPE. Last time we tracked it, it was 58. Now the price is 72, which is really impressive given how the rest of the market has performed.

00:03:00 HYPE, LP Mistakes & Buying at All-Time Highs

Mike: I did start acquiring some HYPE myself. And actually I’m kind of kicking myself, because I first started buying HYPE about six months ago, when they first introduced HIP-3. What’s happening now is kind of what I thought would happen—that perps would start to penetrate the rest of TradFi, and people would start taking HYPE seriously as one of the main perp DEXes.

Unfortunately, what I did was I took that HYPE and stuck it into an Orca LP pool for HYPE-SOL. So it got converted entirely to SOL. I rebought my HYPE at a higher price, and this time I’m just holding it. To me, it’s probably going to be a long-term hold—a small position now. But I do think there’s a chance Hyperliquid represents the decentralized perps token, and as perps get more widespread, the token will do okay.

Fede: I agree with that. Right now it’s very priced—the week before was okay, but I never like to buy things at the all-time high. Even though there’s still upside, if the current price is the all-time high, all the buyers of that asset are buyers who bought at a much lower price. But I have the same thing as you—I bought when it was very low.

[Fede’s Wi-Fi drops briefly; he reconnects with his camera off to free up bandwidth.]

Fede: What I was saying is that I also did the same thing as you. I bought HYPE, put it in a range with SOL, and ended up with 100% SOL. Then I bought some the other day, when we were talking on the live stream, at 40-something. I bought maybe three or four thousand dollars’ worth, and then I sold everything the other day at around seven thousand. So I made about 3K of profit.

Mike: That’s pretty good, actually.

Fede: It’s really good. But at the same time, we missed the large move—when it was 20 was the right place to buy. We’ll always have another chance, though.

00:08:00 Worldcoin: A 3% Slippage Lesson

Fede: Right now the one I’m angry with myself about is Worldcoin. Remember, on Monday I said in the meeting that I sold all my Worldcoin at 0.36. Now it’s 0.51.

Mike: And I think you sold it in the FDUSD market, so you incurred some slippage, right?

Fede: Yeah. I normally sell with a limit order, because that’s a zero-fee market for limit orders. But I was doing it from my phone during the meeting, and everything was going down, so I said, “Now everything is going down, I’ll reduce my exposure for this volatile coin.” I used that market and had 3% of slippage. It was the bad move of the week.

Mike: That’s actually one thing for the traders out there: if you’re selling on an exchange, make sure you know how much liquidity there is for your pair. Usually you want to sell in the USDT market, because that market has the most liquidity. Fede was making a market in the FDUSD pair for Worldcoin, which is thinner.

But the good news is that overall we’re getting better at standardizing our operations using Condor plus Hummingbot API. When you trade manually, you can always fall into these traps and make a mistake. The advantage of Condor is that if you set everything up with routines, you can monitor everything more easily, and automate a lot of these tasks—letting the bot do it for you instead of doing it manually.

00:10:00 The Worldcoin Identity Bet

Fede: That’s a good thing to discuss—what people think about Worldcoin, because I think there’s a chance it becomes a bigger thing. What I’m most bullish on is the interactions Worldcoin will start having with other applications. For example, with a dating app like Tinder: now you don’t know if you’re talking with a human or with an AI. Worldcoin could power those logins.

Mike: To be honest, I’m very skeptical—not because I don’t think they have good technology, but because I think the revenue potential for identity verification is pretty low. It’s not a big market. The percentage of humans they’ve identified is something like 1% of the overall population, and I think they’d have to cross at least 50% for it to be useful from an ID perspective.

To be fair, that might happen in, say, 10 years at the pace technology’s advancing. But Worldcoin has historically traded like a meme coin, because it’s backed by Sam Altman and there was big hype around it a couple of years ago. So the question is more, can they regain that attention from the market? It’s possible. I’m just not sure how quickly they can add new IDs. I’d be interested to see the velocity of new people added.

I do think you can make money trading it, though.

Fede: Before, on the main website, they had that data, but right now I’m not seeing it.

Mike: That’s probably because it’s not looking very good, so they took it down. Sorry—I’ve been in this business too long, so I’m jaded by all the shenanigans I’ve seen. Usually, if there’s no data, it probably means it doesn’t look good.

00:13:00 What’s New in Condor: Five-Minute Controller Snapshots

Mike: Let’s get into the meat of today’s podcast. There have been some changes to Condor in the last week—do you want to summarize what we’ve added?

Fede: Yeah. We added a bunch of small fixes across different areas of Condor and Hummingbot API—improvements on the executors page, and in the routines we added a download feature, so you can download a routine and send it to a customer or a friend.

One very cool thing for when you’re running bots: this was an improvement done in both Hummingbot API and Condor. Now we’re storing a snapshot of the controller performance—realized and unrealized P&L, volume traded, positions held, the P&L of those positions, the state of the executors, and any custom info a controller wants to provide. For example, if your controller provides the current signal, that’s going to be snapshotted every five minutes by default by the Hummingbot API.

That gives you a very fast way to visualize the performance of a running bot without going into the details of each individual trade. It’s like the portfolio page we have—we just take a snapshot of the portfolio, convert everything to the same unit, and we’re doing the same thing here for the controllers. Once you deploy a bot, you have a snapshot every five minutes of how it’s performing. There’s also a combined view, which is really cool because you can see a lot of the controllers working together as one combined performance view—or you can filter to see your individual ones.

There were also fixes on how to update the config of a running bot. Now you can update the config of a running bot, where there was an error before. It’s important to understand that we have two levels of config for the controllers.

Mike: Sorry—real quick, I think it’d be easier to show people rather than tell them, because it’s harder to visualize. Let’s give people a sense of the changes, and maybe run a simple PMM Mister bot to show how the reporting looks.

[Fede’s Wi-Fi makes his screen share too low-res to read, so Mike shares his screen and Fede walks him through it.]

00:19:00 The Runs Tab & Archive Cleanup

Fede: I added this Runs view, which is worth testing. When you deploy a bot, two things get stored. First, a record in the database that says, “This bot was deployed at this time with this configuration.” Second, a Hummingbot container is created—a folder with the database, the logs, the configurations, and everything. You have bot one, bot two, bot three, and each bot has its own data, logs, and configs.

Once you stop a bot, it’s sent to an archive folder, in case you want to do a post-execution analysis after it’s stopped. The feature I added is: when you click “delete bot run”—say because it failed or it was a random run—it gets deleted from the archive bots folder and from the database records. So we don’t keep track of it, which helps if you’re running low on space.

00:22:00 PMM Mister: Global Take-Profit & Stop-Loss

Fede: This is the difference between a general config and a bot config—let me show it with a simple example. First I need to update PMM Mister in Hummingbot API; there’s a small update for the position side just to make it simpler for users. What’s necessary is rebuilding the Hummingbot image with image build -t hummingbot, because there were also fixes in Hummingbot we need to pull in.

Let me deploy a bot. I’ll grab one of the configs I was running locally—let’s say PMM BTC—and put it in Hummingbot API. To upload a config, you have two options: upload the YAML file directly, or just copy it in. So it’s very simple to add a new config.

Another new thing for PMM is a global stop-loss and a global take-profit. This is really nice, because now you can generate much more volume with this PMM—you can be more aggressive, and then use the take-profit and stop-loss to control your inventory and come back to zero. For example, you start 100% quote, so you’re going to acquire BTC—buy, sell, buy, sell—and then you have two outcomes: take-profit or stop-loss. In the middle there’s a lot of market making activity, and if the market range stays in the same place, it’s perfect for you. If the market deviates, you just stop and start over.

The good thing is you can make the process more discrete rather than continuous. And you can always disable it if you don’t want to use it.

00:23:00 PMM Mister vs. pmm_v1: Where to Start

Mike: I’d like to pause and explain a bit for those new to the podcast. What we’re showing is a PMM Mister controller. This is a more advanced single-market market making strategy, built on all the lessons we’ve learned building Hummingbot over the last few years.

There are a lot of configuration parameters, because it lets you deploy self-managing executors across a number of order levels, buy and sell. For each executor you can define an individual stop-loss and take-profit. Once those executors finish, they move the inventory into a “position held” bucket, and you can apply a different global stop-loss and take-profit on that.

One reason I built this is that we’re running it ourselves, and we’re finding that the ability to hold inventory—to not sell at a lower price, and instead wait for the market to rise again, or to control how much inventory you’re holding relative to your wallet—is very helpful from a market making perspective.

It does introduce more complexity, so my advice if you’re new is to check out another controller called pmm_v1. That one replicates the original pure market making strategy from the legacy CLI—it just places orders above and below the price and refreshes them. It’s simple, but it’s probably not going to make money over the long term, because if you naively refresh orders, you’ll likely end up buying at a higher price and selling at a lower price as the market moves around.

So if you’re totally new, my recommendation is to start by running a very simple pmm_v1 controller and understand what’s going on. Once you’re comfortable, migrate to the PMM Mister controller, because that’s how you’ll be able to run things the way a professional market maker does.

00:26:00 Deploying Two Controllers: 3% vs. 7% Exposure

Fede: Thanks for the explanation, Mike. I’ll create two controllers so people can see how you can run two at once. In the first one, PMM BTC, we’ll put 10 executors active per level, and we’ll set the portfolio location—how much you expose around the mid-price—to 7%. The other one, PMM BTC1, uses 3% and 15 executors. This shows how aggressive you can be in exposure.

Mike: And that’s a percentage of your total quote amount? And how much are you allocating to each bot?

Fede: Yes, of the total quote. 1,000 to each. So I have the two configs. To deploy them, I go to “deploy bot,” pick the config, and deploy. It takes a little while to appear—we’ll have a transition showing we’re deploying.

Mike: Let me explain what’s going on. When Fede deploys a bot, the Hummingbot API—which is the backend for Condor—launches a new Docker container. That container is what we colloquially call a bot. This bot has two strategy configurations, and it runs them in parallel using the same container instance. The reason we do this is to let you have, say, five or 10 controllers in a single instance—but you can also separate them across instances, because each instance might be on a different server or operating on a different exchange. You can isolate a lot of the operations involved in quantitative trading into one container. Then the Hummingbot API starts tracking that bot and reporting its performance into this view.

Fede: This is going to look more appealing in the next five minutes, because we capture this data every five minutes. One interesting thing we added is a conversion of all the metrics to a single currency. That’s why you see values like 69.77 instead of a fixed value—it’s converting the FDUSD into USDT.

Mike: So Fede’s deployed two bots, and they’ve already generated a couple hundred dollars in volume. The reason we’re confident letting this run is that the PMM Mister strategy does a good job, if configured correctly, of managing the risk of each order. It sets a stop-loss and take-profit on each level, and globally you can instruct it to have a global take-profit and stop-loss as well.

Our experience is that you can run these strategies for a good amount of time and they’ll make money—some will lose, but break-even is probably what you’ll experience. Unlike the original PMM strategies, the ability to hold inventory lets these at least break even over time net of fees, whereas the original strategies tended to lose money over time.

00:34:00 Securing Your Server: Tailscale & the AI Bot Threat

Fede: One thing I’d like to comment on: nowadays with AI, we’re much more vulnerable to attacks on our servers. We see that when we deploy a new Hummingbot API, it’s automatically scanned by other AIs trying to attack servers. So we’re providing a way we recommend to keep your server secure—already merged into Condor—that uses Tailscale.

If you’re not aware of Tailscale, look it up or ask ChatGPT or Claude. Basically, it creates a local network for all your devices. Our installation scripts will now start by closing all the ports your server has exposed to the web, so you don’t have any vulnerability there. Second, it adds that computer to your Tailscale network, so now only the devices you’ve added can access this new server. Everything works on the same network without you having to expose any port to the outside.

We strongly recommend going that route. CheeseAndGarlic says they use Cloudflare One—that’s another good option. We’re supporting Tailscale because we were familiar with it and it’s very simple. Personally, for my side projects, I use Cloudflare tunnels, which are really good for exposing things to the outside.

Mike: This is quite important. As Fede mentioned, the moment you create any type of server now, there are AI-based bots trying to infiltrate it, automatically scanning for vulnerabilities across all the servers out there. There’s a pull request on the Hummingbot site right now with a Tailscale guide—we’ll try to publish that in the next couple of days, and another guide on the Condor docs.

In the past, because we didn’t have Tailscale set up properly, some people launched servers without using any service like Cloudflare or Tailscale, and they saw bots go in and try to steal their keys. This is really important. Because of AI, the game has changed—there are a ton of bots out there trying to steal money.

CheeseAndGarlic also recommends checking out Socket Firewall and Scanner for supply-chain attacks—a really good suggestion. We appreciate any suggestions the community has on how to make our bots safer. We’ll have our team investigate Cloudflare support after we get Tailscale up and running, because we want to make it as easy as possible for people to deploy their bots safely.

00:40:00 Reading the Numbers: Volume & Basis-Point Take-Profits

Fede: Okay, now my Wi-Fi is working. Remember the difference between the two configs we deployed? The first one, PMM BTC, used 7% around the mid-price, and the other one used 3%. That’s why this one has almost double the volume of the other.

Mike: So when you say 7%, is that 7% of your total quote, and is that the amount in each order level, or in total?

Fede: In total. So with $1,000, 7% means it’s placing $70 around the mid-price. Half is for the buy side, so during the loading period it’s $35 buying first. The second one, at 3%, is $30, so it’s placing $15 per side.

Mike: Maybe a dumb question, but if the second bot only had $15 on the buy and sell side, how did it generate over 260 in volume in only 60 minutes?

Fede: That’s why I wanted to show Binance—it’s buying and selling all the time. The other question is, if it generated that much volume, why is the P&L only one cent? It’s because 251 times 0.0001—that’s the take-profit set here, one basis point.

Mike: I see what’s going on. You’re setting orders, and as soon as they’re filled, you’re setting a take-profit right above, one basis point higher. So you’re always buying and selling right away as soon as everything hits. This kind of strategy is designed to place orders around the mid-price, get them filled, and hedge that risk immediately using the take-profit and stop-loss for every executor. That’s why these strategies are very good at generating volume without a lot of risk.

Fede: That depends on how you configure it. If you increase the take-profit—say three basis points—it would be a totally different game, and the P&L might be three times this. So it depends a lot on how you configure it.

00:44:00 Realized vs. Unrealized P&L

Fede: On the P&L chart, we have two lines. The first shows the P&L evolution over time. We have the unrealized P&L as a dashed line, the realized, and the total. The realized grows as a continuous line, and the unrealized moves independently. Can you guess why?

Mike: I think it’s because the unrealized is based on the position you’ve held?

Fede: Exactly. The unrealized is based on the position held. Right now the position is $29. That means if we start closing it now, we’d be taking profit from that $29 position.

00:45:00 General Configs vs. Live Configs

Fede: Here we have the combined view of these two bots. We can filter to see one, both, or the other. Now, this PMM BTC1—if we go to the editor, we see its config. This is the general config. If we go to Hummingbot API, under configs/controllers we have PMM BTC and PMM BTC1—those are the general configs. But in the deployed instance, inside that bot’s folder, we also have a PMM BTC and PMM BTC1.

So there are two configurations: one general, and once we decide to deploy the general config, it goes inside the bucket of the bot. The bot has live configs inside it, and what this lets us do is modify those configs independently from the main configs. We generate a set of generic configurations, deploy them in a bot, and once deployed, each becomes an independent config we can modify from there.

Mike: Can you give me an example—maybe modify something?

Fede: Let’s say I want to move a value on PMM BTC1. You see here it says min base percentage 0.2. Let me put 0.1 and click save. Config saved—and now if I go back, I see 0.1.

Mike: So that means it’s being used now by the live bot?

Fede: It’s being used by the live bot, but I’m only modifying the config of the live bot—not the original. The original still has 0.2.

Mike: This is really cool, because it means you can have lots of bots running, monitor them, and change their configs on the fly without starting a new instance or stopping them.

Fede: Exactly. Plus, you can modify them live without affecting the original main configuration.

Mike: I’m guessing there are certain things you can’t modify—like the trading pair?

Fede: Right, you can’t. There’s a parameter in the controller—you can see it on the generic PMM Mister or any controller—where, if the parameter is updatable, it has a JSON schema extra that says is_updatable: true. If it’s true, you can update it. You can technically change the other parameters, but the strategy won’t take them into account. Only the ones marked updatable will be used.

00:50:00 “How Do I Make Money?” — The Honest Answer

Mike: Before we move on, let me answer a question from CheeseAndGarlic, who asked about the P&L example I mentioned earlier and how much volume.

Fede: That was on Botcamp, right?

Mike: No, that was just a manual trading example on Solana, from Fede’s own wallet—not with a bot. We get some form of this question every time, because what people want to do with bots is make money. So the way we try to answer it: what we’re building with Hummingbot is a framework—a set of tools that helps you do something. That something might be automating a trading activity, or running a business like market making.

Generally speaking, markets are efficient. There’s no easy way to just make lots of money. It’s not a black box—you can’t just throw money at it. Usually, if you’re running a market making strategy like this, initially you’ll either break even or lose some money, because you have to learn how the market works. Over time, if you stick at it, you can find a strategy. That might be purely making money off arbitrage or market making, but more likely it’s because you’ve identified some inefficiency—providing liquidity on a less liquid exchange and hedging on a more liquid one, market making for a customer who pays you to provide liquidity for their token, or earning rewards on a platform like XRP Liquid that pays for providing liquidity.

The way we look at it, Hummingbot and Condor is a toolset optimized for people doing market making and trading. There’s no big secret, but we’re convinced that if you use Condor and Hummingbot, it makes doing this at scale a lot easier—you can configure each strategy, run them independently, and change them on the fly. So my advice, as always: experiment with a small amount of capital using one of the simpler strategies, and eventually you can scale it to a market maker operation run by a single person.

Fede: One important thing to look at here: remember the difference between the two configs—the portfolio location. The one we exposed more is now suffering more on the unrealized. Why? Bitcoin is going down, and as we expose more capital on each order, we get filled for more, so we end up holding more inventory. If the market goes down, it goes down double. It’s interesting to see this relationship. Right now I’m losing about 81 cents across the two, and made about 10 cents on the two controllers. But this is expected—the market maker is at the minimum base percentage it should be holding, and it has 1.4K more to buy before it’s filled to the max base percentage. This is part of the market making logic.

00:54:00 Routines: Dissecting Hyperliquid’s HLP Vault

Fede: Another thing I’d like to show about routines—I have quite a lot of them right now. For example, I started doing an analysis of the HLP vault, the other day, just from my phone. I strongly recommend getting started with routines. You can organize them by topic, by agent, so you can ask your agent about it. Here we’re seeing the TVL of the HLP strategy.

Mike: This is the Hyperliquid vault—the vault they run.

Fede: Yeah, it’s the HLP vault. The APR is 1.35%, and it has 349 million in TVL. Here’s the P&L of the last 30 days.

Mike: I actually was an investor in this vault a year ago. Back then the APR was something like 30%. One reason I exited was that I wasn’t sure what the strategy was—it was kind of a black box. But I do think this vault is one of the reasons Hyperliquid has done very well: they were market making for their own markets from the get-go, so they had really good liquidity on all the major markets as soon as they launched. And anyone can create these vaults—as a user you can create your own vault and have people invest in it. This vault feature was actually one of the main reasons we added the Hyperliquid connector about two years ago.

This routine’s very interesting—it’s just using their API, right?

Fede: Yeah. And the interesting thing is that the HLP is split: there’s a strategy A, which is losing money, and a strategy B, which is a liquidator vault that’s making money—but overall it’s roughly break-even. On a million in capital it only made about $1,000 in P&L, so it’s not that big. The reason they run two strategies is that Hyperliquid doesn’t have hedge mode like Binance, where you can go long and short at the same time with the same account. Since Hyperliquid doesn’t, they need two strategies to hedge—strategy A in blue, strategy B in purple.

Mike: Interesting—you can tell they’re long and short because they’re inversely correlated.

Fede: Yeah. From what I can see, they’re long on some names and short on others—they even appear to be long on competitors like BNB. (Some of the individual tickers here are hard to read off the dashboard, so I won’t assert the exact set.) The interesting thing I’m trying to understand is how this HLP is getting filled. For BTC, for example, here’s how they’re getting filled.

Mike: That’s a lot of data they have available on the API.

Fede: Yeah, it should all be public. They’re quoting as a maker, but the HLP is also taking. Here we have the trades—open shorts, open longs—and the trade composition: around 26% taker, the rest maker. We can also see the P&L by coin. So first of all, you can analyze the risk the HLP vault has—for example, if a given coin goes down X amount, how exposed it is.

This is all made by Condor. To create a routine like this, you just need to have your Cloud Code or whatever you’re using initialized. You go to Agents—here I asked it to compare the liquidity between Binance and Hyperliquid, because a friend told me there’s a site called hl.eco that says Hyperliquid has three times more liquidity than Binance. I just told Condor, “Give me the liquidity on Binance and Hyperliquid”—and it’s not true what the website says. So there are a lot of lies out there.

You go to the plus button, click the routine builder, and these agents help you create the report. The interesting thing is that the routine is Python code that can call APIs or whatever, and at the end it generates a report—a structure of graphs, indicators, markdowns, whatever you want. You can’t add too much customization, but you don’t need to. You just need to see the information the way you want.

01:02:00 Why Routines Are Condor’s Best Feature

Mike: Honestly, routines are the most useful feature we’ve added to Condor so far. I’m using it all the time now to create reports for analyses I’m doing internally or for clients—we started to market make for a couple of clients. Being able to create a customized report of what’s going on with a market maker operation and send it to a client every day or week is really helpful.

The way we’ve structured it, the report is just HTML, so you can email it or send it via Telegram, and anyone can open it on their phone or in a browser. It’s a really portable artifact. There’s already a scheduling feature where you can run the report continuously—every hour or every week—and soon we’ll add the ability to automatically send that report via Telegram or email to yourself or a customer. We’ll probably also add a hub where you can upload your routines and find ones others have built. We think this routines feature is one of the most useful parts of Condor because of how flexible it is.

Fede: Yeah, and it’s very simple to schedule—you just click Schedule. And to download, it’s right here, Download Report.

01:04:00 XRPL, Rewards & the Exchange Land Grab

Mike: Before we end, one more question from CheeseAndGarlic: “XRPL is very interesting because of the low fees.” I totally agree. XRPL is one of our key partners—they sponsor the Hummingbot Foundation, we maintain the XRPL integration, and we maintain a program called XRP Liquid where people can earn rewards. Right now we’re giving away 1,000 XRP per week for people providing liquidity to the key pairs.

If you’re interested in trading XRPL, using XRP Liquid is a smart move, because you can earn rewards for market making on major pairs like XRP-RLUSD, EUR-RLUSD, or BTC-RLUSD. Especially if you’re new to Hummingbot, you can run either a pure market making strategy or a cross-exchange market making strategy and earn rewards.

What we try to do with Hummingbot is support every major blockchain, CEX, and DEX. There’s constant competition between new and existing markets—every exchange is trying to compete with every other exchange. Right now Hyperliquid is adding prediction markets, and Polymarket and Kalshi, which started as prediction-market exchanges, are now adding perps. Every exchange is supporting different market types and trying to compete, whether centralized, decentralized, or on-chain.

Our job at Hummingbot is that we partner with these exchanges and blockchains, but our real user base is the traders—folks like you and us. As traders, we may favor certain exchanges, but overall we’re trying to make money from the overall market landscape by filling in the gaps: providing liquidity where it’s most needed and taking arbitrage opportunities where they’re available.

On the XRPL minimum order—there’s no minimum order on XRPL, because it’s a blockchain. The transaction fees there are still very low, usually less than one cent, so the minimum order is whatever the blockchain’s basic constraint is—probably less than a dollar. That’s the advantage of these more decentralized chains compared to trading on exchanges. Every chain and exchange has different rules, so there’s some investment you have to make in understanding how to trade on each market.

Fede: That’s a great point. The minimum order amount on Hyperliquid is $10, which is quite high compared to others—it doesn’t let you play around with small capital. On XRPL you can play with $1.

For some reason Binance came back, so I’ll show what the bot we deployed looks like. These orders are the hanging orders, or the take-profits of other executors that were filled, using one-minute candles since we deployed. The bad thing is this market doesn’t have as much activity as it had in the past, but we’re still feeding it trades.

It’s important to understand that we have two limits for placing orders. One prevents us from placing an order based on a cool-down time—after a fill, you need to wait 10 seconds. The other is that to place another order, the distance should be at least 0.1%. That’s why the second order is here. So we have two components validating that we’re not buying too much at the same price.

This market is 65 million in volume. If we check the USDT market, it’s 2.11 billion—so the difference in volume between the two markets is quite large. At some point this market was almost higher in volume than the other one. I don’t know what happened with the FDUSD perps—suddenly they all went down.

Mike: Are you still getting zero fees for making on this pair?

Fede: Yeah, zero fees maker. That’s why I’m trading here. And the minimum order amount is $5. So, checking the bots, we’re probably still negative on the unrealized, but we’re generating volume. In about an hour, the one we exposed at 7% is doing more than double the volume of the 3% one—but it’s also taking more risk. The turnover is more than two times the total quote amount in one hour. So it’s quite a nice turnover.

01:11:00 Condor Builders Cup: An F1-Style Trading Competition

Mike: There’s one thing I want to show before we end. We’ve been making updates to our Botcamp website for the hackathon we’re going to launch shortly. For those who don’t know, Botcamp is our educational arm—we have courses and a cohort a couple of times a year where we teach people how to build bots. Our cohort recently ended—cohort 13—and in it, people built strategies using Condor and demoed them on demo day. You can go to botcamp.xyz/cohorts to watch the demo day recap.

The gist is that the top strategies presented at demo day will represent Botcamp in our upcoming hackathon. It’s an F1-style trading competition: each team selects two strategies to represent them, and for Botcamp those will be the two top strategies from demo day. For example, Raj built a strategy that uses a more advanced academic model to provide liquidity very tightly, so he generated a ton of volume with a small amount of capital in his demo. The second strategy, from Wei Hong, was a cross-exchange strategy that plays two perpetual exchanges against one another. We thought these were very sophisticated, which is why they won.

We already have something like 40 people registered for the hackathon, and you can see some of the strategy ideas they’ve put up. We’ll start the hackathon in about two weeks, so you can already register and get prepared. During the hackathon we’ll have live streams explaining how it works, and you can apply to each of the team sponsors—each team defines its own criteria. For example, Derive would probably pick a strategy that runs on Derive, and they’ve added their own selection criteria.

When the hackathon window opens, you’ll create a strategy, make a video, and apply to a team. You’ll have about one month to build, optimize, and refine your strategy. After that, we’ll work with each sponsor to select the winning agents. Each winning agent starts with $1,000 in capital and races during a 48-hour competition to see who wins. It’s the first time we’re doing this, so it’s a bit of an experiment for everyone—but I’m excited, because it’s a chance for people to build a custom strategy they’ve envisioned, and then we can compare all of them live over a fixed time period with the same amount of capital. We’ll manage the competition process to make it fair.

So if you go to botcamp.xyz and click the hackathon tab, you can register, tell the community what you want to build, and prepare for the hackathon to start.

01:15:00 Wrap-Up

Mike: That was about it. I want to thank everyone for joining this episode of the live stream. We usually do this on Wednesdays or Fridays—we might do it on Wednesdays next time, since we seem to get a slightly bigger audience. We’ll be back next week with more improvements to Condor and more stuff to show you. So please register for the hackathon, install Condor, check it out, and give us feedback on Discord on what you want to see.

Fede: Bye-bye.

Mike: Thanks, everyone. I’m going to play some more music before we leave.

Fede: The track you played at the beginning was very good.

Mike: I’ve been playing around with Suno. There’s a bunch more in the catalog I’ll try to use. All right, everyone—see you next time.

[Outro music.]

We’re back with Episode 8 of The Bot Pod! This week, Mike and Fede highlight the top strategies presented at Botcamp Cohort 13’s demo day, share an updated schedule for the Condor Builders Cup, and demo a big new Condor capability: watching your live bots in real time, with controller snapshots saved every five minutes so you can finally see how P&L evolves over time.

Watch the full episode: YouTube
Register for the Condor Builders Cup: botcamp.xyz
Install Condor: condor.hummingbot.org

Episode Highlights

0:00 Cohort 13 Wrap-Up

The hosts open with Botcamp’s 13th cohort, just wrapped: eight strategies demoed, and—both agree—noticeably higher quality than prior cohorts. The reason is AI. Students used Condor to analyze their strategies and build their controllers, iterating far faster than before.

“We made a great choice in the past—framing our system as building blocks. That’s what now lets AI create agentic algo-trading strategies without too much friction.” — Fede

2:00 Market Discussion: HYPE FOMO & Pre-IPO Stock Perps

Last week we talked up Hyperliquid moving into TradFi via pre-IPO trading of CRBS and other, but never actually bought HYPE at $42. It’s now ~$58, having touched $62. The lesson: talking isn’t trading. They also dig into the new stock perp markets, where thin liquidity creates fat-finger arbitrage opportunities (Fede spotted a ~2% deviation on Microsoft), but where depth is still too shallow for institutions to size up.

7:00 Q&A: Agent Backtesting & Shorts

Answering MJ Lee, the hosts say agent backtesting is coming, but for now you can already backtest V2 controllers in Condor’s Bots tab. On a request for TikTok-style shorts: Carlito (community manager) is already chopping these Friday sessions into clips for YouTube, Twitter, LinkedIn, and Reddit—marketing has just never been Hummingbot’s forte.

“We’re a lot better at building stuff than we are at talking about it.” — Mike

10:00 Condor Builders Cup: Revised Schedule

The hackathon is being pushed back about a month so Fede can extend the agent framework first—soon agents won’t just launch executors, they’ll manage and reconfigure sets of controllers. New timeline: the build period runs June 19 – July 10 with workshops along the way, followed by judging with sponsors, and a 48-hour live competition the week of August 3rd run with the team’s own capital. Registration is already open.

13:00 Demo Day: Wei Hong’s Cross-Exchange Perp Market Making (2nd Place)

Wei Hong rebuilt core Hummingbot components to do cross-exchange market making on perpetual connectors—traditionally a spot-only strategy. His version scans perp markets for opportunities to go long on one venue and short on another, capturing both the price spread and the funding-rate difference. He ran it live: long the stable USDT pair on Binance, short on Hyperliquid.

“Conceptually, you’d be in a position where you’re getting paid to enter, and you earn the funding rate along the way.” — Mike

18:00 Demo Day: Raj’s “Market Making at the Touch” (Winner)

The winning strategy turned market making into a stochastic optimization problem (drawing on an academic paper Mike attributes to Cartea & Penalva). It precomputes a policy, then runs 300-second cycles of placing and liquidating orders rather than recomputing every tick. Raj ran it live on Hyperliquid: 120K+ in volume on a few thousand dollars of capital, with basically flat P&L.

“This strategy is very close to what professional market-making firms—even the algorithmic ones—are running.” — Mike

23:00 Why Condor vs. General-Purpose Agents

Responding to a question about adding Hermes support, Mike explains the thesis: general-purpose harnesses (Hermes, Open Claw) are great, but trading is quantitative, not qualitative. A trader needs the agent to not hallucinate, not make mistakes, and run fast. That’s why Condor offloads core logic to deterministic routines (Python files) and uses the LLM sparingly—both for reliability and token efficiency.

“Condor is structured to minimize the tokens used for decision-making, and offload the core logic to routines, which are deterministic Python files.” — Mike

27:00 Demo: PMM with Take Profit, Stop Loss & Position Hold

Fede demos his work-in-progress PMM controller with global take-profit / stop-loss and a limit chaser. The key concept is position hold: when a position executor fills but the market doesn’t reverse, instead of dumping it, the position is moved into an “effective position”—a long-run inventory bag the bot manages as a whole. Take-profit only triggers once inventory passes a minimum threshold, and stop-loss only once it hits the target—so the market maker has room to improve its entry price before ever taking a loss.

35:00 New Runs Tab & Real-Time Bot Monitoring

Condor gets a new Runs tab (likely to replace the older Archive tab) and, more importantly, real-time bot monitoring. Until now you could only see a snapshot of a bot’s current state. Now every running controller is dumped to the database every five minutes, giving you the full progression of realized/unrealized P&L and volume over time.

“Can we make something that actually lets you see the bot in real time while it’s running? That was the goal.” — Fede

37:00 Five-Minute Snapshots & Custom Controller Info

The data flows over MQTT (keeping the bot lightweight) and is collected by the Hummingbot API—the same mechanism already used for portfolio history. Beyond the standard metrics, a new get_custom_info method lets you push any custom field from your controller into the snapshot stream.

42:00 Live Deployment & On-the-Fly Config Updates

Fede deploys a single bot (Docker container) running three controllers across three markets in seconds, then shows off live updates: you can change a controller’s config and push it to the running bot without restarting. Controllers define which parameters are updatable—change the connector name and it’ll safely refuse. (Next up: a Markdown view that highlights the editable fields.)

45:00 Combined P&L Across Controllers

Once there are enough snapshots, Condor charts the combined P&L of every controller you’re running—and lets you toggle individual lines. Run five algorithms and see them as one portfolio, or drill into any single one.

“I’m running five different algorithms, and this is the combined performance. This will be a game-changer for the agents.” — Fede

“Is this bot doing well because it’s consistently profitable, or is it just getting lucky because the market happened to move in its direction?” — Mike

Next Week

The team is finishing the Hummingbot, Hummingbot API, and Condor changes needed for agents to manage controllers—the reason the Builders Cup moved to June 19. Registration for the Builders Cup is open now at botcamp.xyz. Join us live next Friday on YouTube!

Full Transcript

00:00:00 Intro: Botcamp Cohort 13 Wrap-Up

Mike: Welcome everyone to another episode of the Bot Pod podcast. I’m Mike, this is Fede, and we’re the co-maintainers of the Hummingbot open source framework. How are you doing today, Fede?

Fede: Very nice, everything good. We just finalized the Botcamp cohort—another successful journey, so I’m very happy about that. And I’m really happy with the submissions the students made. There were some very high-quality ones; for one month of training, it’s quite impressive. What about you?

Mike: I totally agree. This was the 13th cohort we’ve done for Botcamp. We had eight strategies demoed on demo day yesterday—I’ll show the winner later in the podcast—but the quality felt quite a bit higher than in prior cohorts. I think it’s because people were able to use Condor to analyze their strategies and help build their controllers. We’re finally seeing the power of using AI in quant trading.

Fede: Yeah, the use of AI is improving the submissions a lot, mostly because they can iterate very fast on the analysis. The other thing is that I think we made a great choice in the past—framing our system as building blocks. That’s what now allows AI to create agentic algo-trading strategies without too much friction, because all those building blocks help the AI design strategies better.

Mike: I’ll show off the winning strategy from demo day. But before we get into it, I have to admit a bit of FOMO right now.

Fede: Me too.

Mike: Because just one week ago on this podcast, we were talking about how Hyperliquid is really getting into TradFi—showing you can trade pre-IPO stocks like Cerebras. But you know what we didn’t do? We didn’t actually buy HYPE when it was at $42 last Friday. What’s the price today?

Fede: I think it should be around 57 or 58, something like that.

Mike: Let me check CoinMarketCap. Yeah, it’s at 58 right now, but it actually hit 60 yesterday.

Fede: It hit 62.

Mike: So basically, we talked about it, but we didn’t actually put anything into action.

00:02:00 Market Discussion: HYPE FOMO & Pre-IPO Stock Perps

Mike: What’s interesting, though, is that the volumes in these pre-IPO stocks aren’t actually that high. SpaceX was about the only one with real volume.

Fede: Right, generally the volumes aren’t quite high there. One thing I was researching across the different markets: there are opportunities to place orders to catch fat fingers, because there are deviations—for example, in Microsoft of around 2%. Someone executes a big trade, and since there isn’t much liquidity, there’s an opportunity to do the arbitrage—but you need to have the limit order already in place.

Mike: Are you talking about the Microsoft perps market?

Fede: Yeah, the perp markets. I think that one is deployed by a different provider, not by Trade XYZ. But across these markets, if you check the liquidity, it’s not that huge. The institutionals will probably start providing liquidity, but institutional traders need this kind of deep liquidity to trade—otherwise it’s not an interesting market. If you can’t get out, it’s not that good.

Let’s say for NVIDIA/USDC—I’m looking at NVIDIA/USDC on Trade XYZ. Up to a value of 1732, up to 7.1%, there’s only about 120K. So it’s not that deep. For someone placing a 500K trade, it would move the price a lot. Actually, a dollar above, there’s more—up to 7.5% there’s about a million dollars. But it’s a perpetual market, so a million dollars in perps isn’t that much either.

Mike: This kind of makes sense, though, because right now NVIDIA trades in the spot markets on the NYSE. So if I’m an equities market maker, it’s actually very easy to make a market on this perps market and just hedge in the spot market on NVIDIA. I actually think we should add an equities connector at some point to Hummingbot—like Alpaca or Interactive Brokers—because our users probably want to do the same thing.

00:05:00 Equities Connectors & Binance Prediction Markets

Fede: The thing is, if all these stocks start trading in the spot, I think they’ll naturally appear in these exchanges too. Actually, Binance is listing all of this. That’s another interesting thing—I don’t know if you saw, but Binance released prediction markets.

Mike: Really?

Fede: Yeah, they released prediction markets, and they also released SpaceX. They’re catching up. But one interesting thing I saw about Binance is that they have something like 10,000 employees, and Hyperliquid has only 11. So there’s a big bias there.

Mike: Hyperliquid is our type of organization, right? Maybe they’re even better than we are—small number of people, but they try to do a lot. From a regulatory perspective, both Hyperliquid and Binance are doing an end-around on US regulations. I’ve heard there’s a lot of talk in the US about how the CME is lobbying for more restrictive policy against Hyperliquid and Binance, to protect the sanctity of US markets. So that’ll be a really interesting watch.

00:07:00 Q&A: Agent Backtesting & Shorts

Mike: But let’s get into it. We already have some questions from the audience. Let’s answer one from MJ Lee: “Are there any plans for Condor agent backtest support, other than deterministic script-based backtests?”

Fede: Yeah, to backtest the agent—I think we can add that. It won’t be so difficult. And nice, because if you’re asking that, it means you’re probably using the agent framework. Based on the output of the cohort, we found it might be smarter to have an agent be in charge of deploying controllers and modifying their config, rather than trading directly. But if you’re doing grid trading, the agent is enough. So yeah, we can add something like that.

Mike: My thought is to initially try backtesting using the backtest tab in the Bots section in Condor. Backtesting was always one of the most requested features in Hummingbot. We originally added it to the dashboard—the GUI for Hummingbot—a couple of years ago, but when we built Condor, we combined those capabilities into Condor. So you should already be able to backtest V2 controllers using Condor. And one of the changes Fede will talk about later is how we’re planning to let agents manage controllers more effectively in the future.

Fede: Yeah, I think that’s the way to go—agents directly. There’s one more question: a user asks, “Guys, why not create short videos, TikTok style?” You want to be a TikToker, right?

Mike: The first thing I’ll say is that marketing has never been our forte at Hummingbot. We’re a lot better at building stuff than we are at talking about it. But we have been creating more shorts and clips. Fede and I record here every Friday, and our community manager, Carlito, takes the videos, chops them into shorts, and publishes them on YouTube, Twitter, LinkedIn, and Reddit. We don’t do TikTok yet, mostly because of bandwidth. If you follow our Twitter handle, @_hummingbot, you’ll see some of those clips. And Deja—thank you for offering to help with marketing. If you have ideas, join the Discord and post them. As I said, we’re builders, not marketers, so we appreciate any help the community can offer.

00:10:00 Condor Builders Cup: Revised Schedule

Mike: So let’s get into it. There are two things we want to do today. First, I want to talk about the upcoming hackathon—we’re revising the schedule—and show off a strategy someone created during the cohort, because it’s a good example of what people can build during the hackathon. Then Fede will demo some new Condor features that make it easier to manage your bots.

We’re revising the hackathon schedule a bit. It was supposed to start today, but based on feedback from the Botcamp students and the strategies they built, we’ve decided to modify the agent framework. Currently, agents in Condor can launch executors, so they can trade. But we’ve found a better role for the agent might be monitoring an existing HFT strategy—and Hummingbot already has a good framework for that, called bots and controllers. So Fede is going to change the agent framework so that, in addition to launching executors directly, the agent can manage a set of controllers and modify them.

We’ll be making those changes over the next couple of weeks so people can use them when the hackathon starts. That’s why we’re delaying the hackathon by about a month. The hackathon period will run from June 19th to July 10th, with a series of workshops to teach you how to build your agent strategy. After that, we’ll have a judging period where we work with our sponsors to select the winning agents, and we’ll prepare those agents to “drive,” so to speak, in a 48-hour live competition the week of August 3rd.

So it’s delayed a bit, but we hope this lets you create more sophisticated agents that manage true bot strategies. Registration is already open, and we’ll have more resources for registered folks before the 19th.

00:13:00 Demo Day: Wei Hong’s Cross-Exchange Perp Market Making (2nd Place)

Mike: Let me show you some of the strategies people built during demo day. We had eight different strategies, and honestly, they’re all quite impressive. Some were directional, some market making; some traded on DEXes, others on order-book exchanges. I was really gratified to see how much work the students put in, especially given that the Condor harness is fairly new and they had to overcome bugs and other issues along the way.

Let me start with Wei Hong’s, which was the second-place winner. I thought it was quite impressive because he actually rebuilt a lot of the core components in Hummingbot to do it. What he built was a strategy that does cross-exchange market making, but on perpetual connectors. Traditionally, our cross-exchange market making only handles two spot exchanges, but with perpetuals you can now do the same thing on perps.

He built a strategy that analyzes different perpetual markets and finds opportunities to do cross-exchange market making—taking into account both the funding-rate differences between the two perp exchanges and the prices. When it identifies an opportunity, the strategy enters one long position and one short position, and hopefully captures the spread between the price differences as well as the funding-rate difference. Conceptually, you’d be in a position where you’re actually getting paid to enter, and you earn the funding rate along the way.

Fede: Just as a reference, I created a video about two or three years ago doing funding-rate arbitrage between Hyperliquid and Binance perpetuals. I showed that if you enter both positions at market, you need almost two or three days of funding fees to recover the trading cost. The recommendation was to enter the position progressively, which is what Wei Hong is doing here—taking profits while entering a position he’ll be paid to hold.

Mike: I was also impressed by how he got the strategy working in production. You can see the bot he was running: a long position in the stable USDT pair on Binance, and a short position on Hyperliquid. He was capturing some unrealized and realized P&L, and also taking advantage of the funding-rate differences. Overall, a very impressive example where the student added his own custom executor and custom controller, and the strategy makes sense conceptually. We may even want to have this as a type of executor in Hummingbot later on.

Fede: Yeah, we should.

00:18:00 Demo Day: Raj’s “Market Making at the Touch” (Winner)

Mike: This was the number-two strategy. The winning strategy was by Raj, called “Market Making at the Touch.” Let me explain it, since I could hear the audio on this one. Raj took concepts from an academic paper—I believe by Cartea and Penalva—that talks about how to turn market making into a stochastic optimization problem.

The idea is that when you acquire assets, you want to sell them to get back to neutral; if you sell, you want to buy them back; and in the middle, when you’re at a neutral position, you’re placing both orders. What he’s doing is creating 300-second grids and repeating that cycle every 300 seconds—placing orders and then trying to liquidate. Once we post the strategy video and he explains it, it’ll be easier to understand.

There’s quite a bit of academic theory here in terms of how it’s done, and he generated some really impressive visualizations to analyze what’s happening at various points. Essentially, he’s creating a policy that defines how the strategy should act. Because the policy is predefined, it’s easier to just run it instead of doing computations every tick. So this is very much an advanced market-making strategy based on more academic factors.

What also impressed me is that he ran the strategy live on Hyperliquid and generated over 120,000 in volume with basically flat P&L—and with only a few thousand dollars in capital. In my opinion, this strategy is very close to what professional market-making firms, even the algorithmic ones, are running. It was a combination of the academic approach and real results in the wild, and that’s why he got the most votes. It was a very close competition between him and Wei Hong for the top slot, so I’m hopeful Wei Hong can also submit his strategy for the hackathon and win one of the other slots.

Fede: This is really cool because one of them presented a professional-grade market-making strategy using a paper as inspiration, and the other went full operational. One guy with $1.5K traded 120K on spot in four hours—very impressive. And the other was trading perpetual positions of more than $5K into the exchanges. If you’re trading that amount, it’s because you’re confident in your strategy.

Mike: I totally agree. And that’s why we’re doing this hackathon—during the cohort we had about eight submitted strategies, but with the hackathon a lot more people will get the chance to show what they can do with Condor, and we’ll see which strategies actually work in the wild.

To reiterate: the hackathon starts officially on June 19th, and you’ll have a three-to-four-week period to build your agent. Along the way we’ll have workshops, then we’ll judge the strategies with our sponsors, select the winners, and run the five or six winning strategies with our own capital in a sandbox environment for 48 hours to see which generates the most P&L and volume. So, a final call-out: join the hackathon. You can find it at botcamp.xyz, and we’ll have more information over the next couple of weeks.

00:23:00 Why Condor vs. General-Purpose Agents

Mike: Let me answer one more question, from Digita, before we move on to the Condor updates: “You guys should add Hermes agent support. It will greatly boost.” Our community manager, Carlito, has been doing a lot of experimentation with Hermes—using it to schedule the publication of YouTube clips and shorts, and to notify people on Discord about changes.

The reason we’re building Condor, though, is that most current agentic harnesses—whether Open Claw or Hermes—are meant for general-purpose agents. That’s great; I use them quite a lot. But as a quant trader, trading is different from general tasks because it’s quantitative. LLMs are really good at qualitative, subjective, probabilistic tasks. But if you’re doing quant trading, a lot of the time you want the agent to not make mistakes, not hallucinate, and run very quickly.

So with Condor we’re trying to design a harness that uses LLMs, but uses them to accomplish the tasks traders actually need—operating from a first-principles approach. Later on, we could probably make Condor agents more compatible with Hermes or Open Claw, so you can run them in those platforms. But for now, we’re trying to create an interface that’s purely designed for trading. That’s why routines—deterministic scripts—are the initial primitive, and trading agents are the second.

Fede: I agree. I tried Hermes too. It has 89 prebuilt skills and all that. The only really interesting thing is the auto-feedback loop that improves the skills automatically—but that’s something we can easily add to Condor. For our harness, it’s probably not what we’re looking for.

Mike: Everything is new, so it’s a very open landscape—maybe there’s a way to make them more integrated in the future. But right now, when I’m trading, I want something dedicated to trading, not a general tool. Also, from a token-efficiency standpoint, you don’t want to just give API docs to Hermes and have it figure out trading for you, because that would be very expensive. That’s why Condor is structured to minimize the tokens used for decision-making, and to offload the core logic to routines, which are deterministic Python files.

Fede: Yeah, I agree.

00:27:00 Demo: PMM with Take Profit, Stop Loss & Position Hold

Mike: That’s a good segue. In the second half of today’s podcast, Fede’s going to demo the changes he’s been making to Condor to make it better at managing our bots, so you have more visibility into what’s going on. Do you want to take over and show what you’ve built?

Fede: For sure. Let me share my screen. Can you see it?

Mike: Yep.

Fede: I’m currently adding to the PMM Mister controller. The take-profit and stop-loss feature is working quite well right now; I’m just figuring out one issue with the sell side that’s also creating a sell position. Thanks to that bug, I ended up with a position of 4K USD, and when I saw it was about $40 in profit, I just took it. But I’m trying to fix that position-hold bug.

The good thing is that the stop loss works, and it’s actually doing it with a limit chaser. It’s incredible how well the limit chaser works—I was watching it live and it was really nice. You can see how it’s trading.

Let me explain the position bars to everyone. This first bar that’s loading shows the mean position I can have, the target position I’d like to have, and the max position I’d like to have. Based on that, the bot accumulates a portfolio, and depending on its stop-loss value and current position, it decides whether to take the loss or not. There are a lot of conditions that need to be met to actually take the loss.

You see here, “closing position stop loss”—it tries to close the position, and it did. Now we have only 13 cents. There are parameters you can configure: global TP enabled, global SL enabled, the values you pick for them. And the take-profit should only trigger if you’re above the mean-based percentage, because you can be loading inventory. For example, now we have $25 and the global take-profit is $1—but you don’t just take it; you need to fill this inventory bar first.

Mike: Can I ask a question? The global take-profit and stop-loss—how is that different from the take-profit and stop-loss at the position-executor level?

Fede: Each executor has its own take-profit. But when an executor gets filled and the position isn’t reversed—because the market went down—I don’t want to keep that position by itself. I’d like to keep it as part of my big bag of positions. That’s what we call position hold. These executors are the position executors; after a certain amount of time, they’re moved to the “effective position.” Once they’re moved there, we manage our position in the long run.

So in this case, now that we’ve started, we’re still losing money, but it’s okay—I’m running with very aggressive parameters in order to fill the position and trigger these take-profit and stop-loss scenarios, because that’s what I’m testing. Now it’s able to take profit because it’s above the min base percentage. If the market suddenly goes up and the P&L goes above the take-profit, it’ll take profit.

The stop-loss is only activated when the inventory reaches a target base. This is because I still have room to buy more—the market maker has room to buy more—so I don’t want to say “you’re taking the loss right now.” Let the market maker acquire more inventory, and maybe after some time we can improve our entry price and not need to take the loss at all. That’s the point.

Mike: I see.

Fede: I’m trying to fix this on the Hummingbot side to make the PMM Mister work with perp trades, plus this stop-loss feature. And on the Condor side there are quite a lot of improvements I’m finishing. To use this, you’ll need the latest Hummingbot image and the latest Hummingbot API image deployed.

Mike: Sorry—doesn’t the Hummingbot API automatically fetch the Hummingbot image, or does the user have to pull the Docker image?

Fede: I think if you use the update command, it should do it automatically. David, if not, you can review that process later, or just let us know if you have issues. Otherwise, go to where you have Hummingbot API, run git pull, and update your version—but I think it should work directly.

Mike: You mean the update command in Condor—the Telegram condor update command?

Fede: Correct.

00:35:00 New Runs Tab & Real-Time Bot Monitoring

Fede: Let me go to Telegram and ask for the web link. This is Condor. As I mentioned before, I added a color-blind mode last week for one of my friends. Now I’ve added this Runs tab, which I’m going to be testing—it lets you delete the bot archive from the Hummingbot API.

Mike: Does the Runs tab replace the Archive tab? Is archive still there after you delete?

Fede: Archive is still there, but I’m pretty sure I’ll remove it, because it’s not working with the efficiency I think we should have. The routines, with their HTMLs, will probably replace it too—but I can’t confirm that yet.

Mike: So the Runs tab shows the bots you’ve run, both archived and non-archived?

Fede: Yeah. Everything you stop gets archived.

Mike: I see “deployed bot” here too. So this page shows all the bots you’ve run, archived and non-archived—that’s why you can probably get rid of the Archive tab, since this page is more complete.

Fede: Right. The one that says “deployed” is because I removed it manually—the record is in the DB, but I removed it from the file system, so it appears as deployed instead of archived. In this tab, I just deployed three random controllers. Let me build the Hummingbot image so we use the latest one.

00:37:00 Five-Minute Snapshots & Custom Controller Info

Fede: The change I introduced to the Hummingbot API is that when you have a controller running, that controller is now dumped to the DB every five minutes by default. I think that’s the right interval. At some point we might go to one minute for real-time control, but every five minutes gives us only about 30 records per hour—otherwise we’d have a ton of records in the database, which probably isn’t worth it. Basically, we now have near-real-time information.

What we’ll have now is the progression of the P&L, the position hold, and everything over time. Right now, in this view, I’m just seeing a snapshot of how the bot is doing—a picture. I can’t see the truth of what actually happened over time. So my point was: can we make something that actually lets you see the bot in real time while it’s running? That was the goal.

The other thing is that the information we collect from the controllers is naturally the realized P&L, the unrealized P&L, the global P&L, and the volume traded. That data is available, but I also exposed a get_custom_info method that you can add to your controller. If you look at the PMM Mister get_custom_info method, everything you put in there will be sent through the MQTT broker.

00:40:00 How the Data Flows: MQTT & the Hummingbot API

Mike: Let me paraphrase to make sure I understand. Right now in Hummingbot you see the real-time performance of the bot, but ideally you want to see how the bot has traded over time. So you’re sending a snapshot of the performance summary—plus anything the user puts in custom info—every five minutes. Where is this data being sent?

Fede: The data flows through MQTT, so the bot stays very lightweight—we just send the data over MQTT and collect it with the Hummingbot API, which then has the real-time data. The only new thing here is: it’s good to have the real-time data, but now let’s also save a snapshot every five minutes so we can construct the history later. It’s the same mechanism we already use for the portfolio—as the Hummingbot API runs, we can see a one-week portfolio with snapshots every five minutes. We’re doing the same thing, but for the active bots.

00:42:00 Live Deployment & On-the-Fly Config Updates

Mike: So right now it’s creating a new Docker instance for the bot, and in that instance it’s running three different strategy controllers—one for each trading pair?

Fede: Yes, exactly. Here’s the bot that’s running—it started about 22 seconds ago. It’s already trading on three different markets. We don’t have a position on every pair yet, but now we have positions in each of them. This view shows the data live. If we enter one specific controller, the historical data isn’t available yet, because we take a snapshot every five minutes, so it’ll take a little while to get the first one.

We can also change the config of the bot from here, save it, and update the running bot in real time. That’s a really cool thing you can do.

Mike: Wow, that’s fun. So it updates on the fly—you don’t need to stop the bot?

Fede: Yeah, it updates on the fly. This is a new feature. Honestly, this form is a bit of a pain compared to the editor we have here, so maybe I’ll just add a Markdown view on the left in this style. What do you think?

Mike: I think so too. It’s more useful, but we’d have to know the types of each field and constrain them. If a user can put in arbitrary items, it’s probably better to have Markdown. The only thing is: are there certain values you can change? For example, if you change the connector name, would it break the context?

Fede: The controller itself has a concept of updatable or not—I’m marking which fields are updatable and which aren’t. So it doesn’t matter if you change the connector name; since it’s not updatable, it won’t let you change it.

Mike: Got it. If you go to Markdown, you might be able to highlight the ones that are updatable—bold them, or gray out the ones that aren’t—so the user knows what they can change.

Fede: Yeah, good idea.

00:45:00 Combined P&L Across Controllers

Fede: Now we have the first information here. If we go to Bots, we need at least one more record—we’ll see another line in the next five minutes showing the change. As you can see, we have the realized, unrealized, and total P&L, and the volume on a different scale. Once we have position hold, it’ll also show that.

For reference, I think we pasted on Twitter and in Discord how it looks. I’m currently changing the layouts a bit. Another cool thing is that here we can switch through each controller individually—though right now it’s not letting me switch; there’s something blocking it because I just made a change in the PR that I need to review.

Once we have more than two records, this shows the combined P&L of all the controllers you’re running. That’s really cool, because you can see, “I’m running five different algorithms, and this is the combined performance.” Some can go well, some can go wrong, but the interesting thing is you can see the combined performance.

Mike: Just so I understand—those three controllers are running in the bot below, which is basically the Docker instance managing those three controllers?

Fede: Yes, exactly.

Mike: Should the user be concerned if they see errors, or is that part of normal operation?

Fede: If they see errors, they should look at them to understand what they are. For example, “open order failed” usually happens if you’re using limit-maker orders and the order the bot sends crosses the mid-price—it would match and take while crossing the order book. That can happen if you’re sending an order that’s un-updated, or in my case, sending orders very tight. Another error here is that I tried to set a leverage of 20, and 20 isn’t valid for this pair. So you want to look at these and see if there’s a specific error.

The good thing is that here we have a view of controllers—that’s probably what you care about. But remember those controllers can be deployed in different bots. If I deploy three more controllers, I’ll see another bot with three controllers. The bot is the Docker container; the strategies run under that container. I can deploy another Docker container with three more controllers, and that results in another bot.

I actually broke the visualization—it was showing the full-screen thing, so I’ll probably fix it today. I just pushed it.

00:49:00 Why Time-Series P&L Matters for Agents

Mike: I get the general concept, and it makes a lot of sense, because when you’re trading it’s not just a point in time. You run a bot for a day or a week, so you really need to see how the bot is evolving—how the P&L evolves over time. That gives you a lot of insight: is this bot doing well because it’s consistently profitable, or is it just getting lucky because the market happened to move in its direction?

Fede: Exactly. And this is where I think the agent will be good—almost in real time—at understanding what’s actually happening. For example, this BIL market has most of the realized P&L. Why? It has the most volume and the lowest unrealized. So the agent should say, “Okay, let’s allocate more total quote to BIL instead of the others, because it’s making more realized P&L.” Now that we have two points, you can see it. This combined view is the realized P&L of all the controllers. If I want to see just one, I can isolate it. This is really cool—I think it’ll be a game-changer for the agents.

Mike: I think that’s also why we should use this in the trading competition—being able to see the performance of different bots and how they rank against each other. We basically need the same data to make the competition more interesting.

Fede: I agree. This is what I’m working on right now, and it involves changes on both the Hummingbot side, the Hummingbot API, and Condor—that’s the only downside. But overall it’s really cool.

00:51:00 Wrap-Up

Mike: Just to wrap up—this is actually why we’re delaying the hackathon by a few weeks. We want to make sure the agent can manage controllers like this, so you can have a set of controllers running and your agent can make changes on your behalf—a more agentic strategy. Hopefully we can finalize all those changes in the next few weeks so that when the hackathon starts on June 19th, you’ll be able to deploy agents that manage this for you. Registration is already open, so if you’re interested, sign up—we’ll be sending emails to the registration list over the next few weeks with more resources and information about how the hackathon works.

Fede: See the difference in how it’s trading now compared to before? Before it was much more aggressive—well, it’s still aggressive now. But notice how fast and easy it was to deploy three bots on three different markets. Even if some of these markets aren’t very competitive, it’s quite interesting how easy it is to do. That’s all for me—I’ll push this, and it should be available very soon.

Mike: Nice. Just to wrap up, thank you all for joining another episode. We’ll be here next Friday again—Fede will actually be in Europe, so it’ll be a little more interesting. Next week we’ll probably cover more changes; we try to cover every change we make to Condor on a weekly basis. And starting June 19th, when the hackathon starts, we’ll use these weekly sessions more as workshops for the folks attending, to guide you in building your agents.

One last thing—I’ve always wanted to do a regular podcast. Part of me wants to be semi-famous, so to speak. We have about 10 viewers on average right now; hopefully we can grow that 20% every week and get to hundreds, if not thousands. So that’s my ulterior motive. Really, thank you everyone for joining and asking questions. We’ll see you next Friday.

Fede: Bye bye.

Watch the full episode: YouTube

Install Condor: condor.hummingbot.org

Episode Highlights

2:00 Crypto as an Oracle for TradFi

Mike’s friends in traditional finance are increasingly excited about Hyperliquid. The standout story: a Citrini tweet about funds watching CBRS (Cerebras, the AI inference chip company) trade on a Hyperliquid HIP-3 market for price discovery before the company has even IPO’d.

“Crypto markets are becoming almost true oracles for what might happen in traditional finance. When this thing actually IPOs, guess what those initial market makers are going to use for the reference price?” — Mike

5:00 The Risks of “Perps on Anything”

The hosts talk through the counterparty risk in these new market types. Fede points out that every big crypto crash he’s seen came from a broken trust between counterparties—and a thin perp market on a niche index could leave traders unable to exit positions.

“Having lived through FTX, there’s always something unknown about any type of leveraged perp DEX.” — Mike

8:00 Spot vs. Derivatives: Two Different Animals

Mike draws on his finance background to separate market types: L1s like Solana and Base are where new tokens are born and experiments are run (spot), while a perp DEX is a pure derivatives market for anything you can leverage. They also touch on proof.trade’s conditional-value markets and MetaDAO’s decision markets.

11:00 The Prop-Firm “Funding Test” Model

Fede and Mike dissect how FX brokerages and prop firms really work—identifying winners and losers, and the “funding test” model where traders pay for an account, trade on paper, and most of them fail, generating free money for the issuer.

16:00 Why Routines?

Mike frames the core idea of the episode: turning data into something usable used to take a long time—collect, clean, parse, visualize. Routines collapse that. Combined with Hummingbot’s connectivity to every exchange, “anything you can dream of can be built on top of routines.”

18:00 Does Hummingbot Actually Make Money?

Answering an audience question, the hosts are clear: Hummingbot is a framework, not a magic money box. Fede shares a concrete example—a client market-making fiat pairs on Binance, ~$1.5M/day volume, earning ~9% monthly on rebates alone before trading PnL.

“If you’re expecting to click a bot and make money, you will fail. It’s a framework—it has all the primitives you need.” — Fede

21:00 Demo: Memecoin LP Yield Hunter

Mike demos a routine he built that uses the GeckoTerminal API to fetch the top Solana pools, ranks them by yield (fees ÷ TVL), and filters to concentrated-liquidity pools so he can set single-sided SOL ranges instead of buying memecoins outright. He then pairs it with an agent—Memecoin LP Yield Hunter—that fills three LP slots, monitors them, and redeploys capital as positions auto-close.

“Although it needs some iteration, it basically did what it was supposed to do. So far I’m pretty much in the black in all the pools.” — Mike

30:00 Routines Are the “New Reporting Era”

Mike shows a second routine that visualizes his live LP positions against each pool’s liquidity distribution—and how he iterated on it, asking the agent to add more detail with each run.

“This is a revolution. Routines and reports are the new reporting era—dynamic visualization. You have an idea, you plot it, then you reproduce it over and over again.” — Fede

33:00 Architecture: Agents, Routines, and learnings.md

Fede explains how it fits together: an agent (powered by an LLM) helps you build routines that surface exactly the data you need. Once built, that data is automatically available to your trading agent, which has tools to create and stop executors—and maintains a learnings.md file so it improves over time.

36:00 Condor UI Tour

Fede walks through the latest UI: multi-currency portfolio conversion via the rate oracle, the trade interface for running grids across any CEX, the executors view, and a pairs-trading agent built live in Botcamp that creates grids based on deviations.

42:00 Order Book Depth Across Exchanges

A standout routine: built with agent mode in minutes, it pulls order books from four exchanges and compares depth and spread in BPS around the price. Fede uses it to spot a real cross-exchange opportunity on AAVE and a 90 BPS spread on a memecoin—leading Mike to plan a CEX/DEX cross-chain market-making routine on the TROLL token for next week.

48:00 Accessibility: Color-Blind Mode

A small but meaningful touch—Fede added a color-blind theme alongside dark and light modes after a friend who uses Condor asked for it.

Next Week

Mike’s homework: extend the order-book arbitrage routine with a Jupiter (Solana) leg and report back on whether there’s a real CEX/DEX arb on the TROLL token. Join us live next Friday on YouTube.

Full Transcript

00:00:00 Intro

Mike: Welcome, welcome everyone. This is another weekly episode of the Bot Pod podcast. I’m Mike, this is Fede, and we are the co-maintainers of the Hummingbot open source framework. Lately we’ve been working on this new agentic harness called Condor. It’s like Open Claw, but for traders.

We’ve been focusing this podcast on weekly demos of all the new features that Fede—mostly Fede, but maybe 10% me—have been adding to the harness. This week Fede’s going to demonstrate some new changes to the user interface, as well as take a deeper dive into how routines work.

Overall, we think routines are a really powerful new primitive in Condor. Combined with LLMs, they can make a lot of trading-related tasks a lot easier. But before we get into that, like we always do, let’s talk about what’s been going on in the markets lately.

00:01:00 Market Discussion: Markets Are Hot

Fede: Hi, everyone. How’s it going? The markets are really hot right now. You don’t know if it’s going up or going down. Bitcoin could break 80K. Hyperliquid went up 20% yesterday—well, maybe 15%, but still a lot. Now it’s going back down a little.

A lot of things happening. A lot of uncertainty, but I think this is a time to build portfolio, build strategies. As I said last time, we’re probably at the lowest point of crypto prices over the last two years for some tokens like Solana. And I still see the market evolving—more transactions being processed, more fees collected, more real-world companies getting into the chains. So I’m bullish on this.

00:02:00 Crypto as an Oracle for TradFi

Mike: What’s interesting—I’m actually on the East Coast this week. I’m here for my 25-year college reunion. Yes, I am that old. I stopped by New York on the way and met up with some friends in traditional finance who are crypto-adjacent. It’s really interesting because a lot of them are super excited about some of the things happening in crypto lately, especially around Hyperliquid.

We talked last week about Hyperliquid and their HIP-3 markets—how they’re basically creating perpetual markets for all kinds of things where there’s some observable index price. For example, oil is one of the third or fourth biggest tradable markets on Hyperliquid. But now you also have silver, the S&P 500.

There was a tweet this morning from a Twitter account called Citrini that a lot of people in TradFi follow. Let me read it: “Have gotten four different calls today from funds for watching CBRS trade on Trade XYZ for price discovery. Pretty surreal.”

Fede: Yeah, it’s crazy. They’re trading the price discovery of this new company.

Mike: Exactly. But this isn’t just any new company—it’s Cerebras. Cerebras is actually just down the street from me, literally about two miles from where I live. They’re very secretive, but apparently they’re building some type of AI inference chip. Now that there’s so much demand for AI, the load is shifting from training to inference. If they can build an inference-specific chip that’s faster or lower power, this could be the next big IPO.

So to me, what’s interesting is that crypto markets are becoming almost true oracles for what might happen in traditional finance. When Cerebras actually IPOs, guess what those initial market makers are going to use for the reference price of CBRS? I believe they’ll use this Hyperliquid HIP-3 market.

So I do think perps on anything is actually a viable outcome. I’m not saying it’s going to happen, but—not financial advice—we should probably start accumulating some HYPE.

00:05:00 The Risks of “Perps on Anything”

Fede: Yeah, I agree. We were discussing today what the risks are. Personally, all the big crypto crashes I saw were when someone broke the trust of the other counterparty. If we’re trading on a market like this and suddenly all the players go to zero funds, then the market doesn’t exist and you can’t trade or get rid of your positions. That’s something that might be complicated.

Mike: Definitely. Having lived through FTX, there’s always something unknown about any type of leveraged perp DEX—especially since they’re also doing the market making. There’s some tie-up between HLP, the market-making vault, and the exchange. So there are some similarities. I definitely hear you on the risk. It’s not financial advice.

Fede: Not financial advice, but there’s a part of me that says you have to be careful with these because I don’t know where it can go. At some point, if someone creates a similar thing on Solana—I think the Cheetah guys will have a very good chance with their CTX exchange, because Solana has a lot of liquidity. All the tokens are tradable, even meme coins, because there’s a lot of liquidity for all of them.

If someone can combine the experience of AMMs for perps with an order book—similar to what XRP has, where you combine the order book and limit orders—I think the liquidity in Solana would probably be better and people would choose to trade there. But for now, Hyperliquid has the best experience. The point of why it got so good is that they’re basically a Binance terminal on a blockchain—anyone can feel the same experience as trading on a CEX.

00:08:00 Spot vs. Derivatives Markets

Mike: I totally agree. But I think there’s space for an exchange—a CEX or DEX like Hyperliquid and Binance—which is about trading currencies, major coins, those kinds of things. And there’s also room for another kind of chain for meme coins, where things are created and born. That’s basically an L1—composable, like what HyperEVM is supposed to be.

But that’s a different animal from a perp DEX, or even a perp CEX, which is just a leveraged futures market. It’s more like a pure derivatives market for any instrument you can leverage and trade. So you still need a spot market for those things, and you need a spot market for new assets generally. They serve a different purpose from a market-design philosophy perspective.

Fede: Yeah, you still need both. Hyperliquid did really well at the perp side, not so much the spot side.

Mike: I agree. That’s why I think an L2 makes sense—something customized to fit that market. Whereas the edge Solana has is all these different competing startups creating various types of markets. There’s one recently announced by my friend Squid in the Solana ecosystem called proof.trade. He’s trying to create impact markets—basically trading the value of something conditional on some event happening. For example, what would the price of oil be if there’s a truce between Iran and the US.

As a statistics nerd, I like the idea of conditional probabilities and expected value given some probability. It’s a different spin on prediction markets—prediction markets trade whether an event will be one or zero, and this is more like trading the value of something given that event. Another example is MetaDAO, where they’re trying to make decision markets and futarchy happen to govern tokens.

So to me, Solana and Base and other L1s are the chains where things are born and experiments are run, creating new spot tokens. And then there’s another need: how do you create derivative markets. This is also why, when I worked in finance, these were different departments—equities on one floor creating new companies, and fixed income or derivatives on the floor above, which is what I worked in, creating all kinds of funky derivatives.

Overall, whether it’s spot or derivatives, I think crypto’s going to take over finance generally. Sorry to our friends in TradFi, but in 20 years it’s all going to be crypto.

Fede: I agree. Everything will move to crypto. It’s really interesting, the things that are happening.

00:11:00 paper.trade & the FX Prop-Firm Model

Fede: Did you see this paper.trade XYZ? It’s another vision thing happening on Solana. Basically you’re trading against an LP—the paper token. You have 1,000x leverage to trade, and they have a mechanism of queues for getting paid. The long bet is that the value of the LP will grow as people lose against it by trading the markets.

Mike: Those are the things that usually crash, but there’s something interesting here. It reminds me of a conversation I had with a Hummingbot user—I won’t disclose who. They were telling me how the FX brokerage game works. They give you an account, and what they’re really trying to do is identify who’s a winner and who’s a loser.

The winners, obviously, they can give more capital to and you can actually profit—the incentives are aligned. But identifying a loser is also valuable, because you want to trade against a loser and take the other side. The reason they give people an account is that just making that identification is worth more than the value of the account they’re giving up. Most of the value comes from identifying the losers, not the winners.

When I was in Mendoza after your wedding, the guy who drove me around was basically one of these guys getting the accounts. He was trading FX, and I tried to convince him to try crypto trading—”Why don’t you trade FX on Binance perps?” But then he told me about this model and I realized the whole incentive structure is different. Binance isn’t going to give people $100 to trade with on Binance Futures, but these FX brokers are giving them $100 accounts.

Fede: I think it’s also a Ponzi model. The way it works is they make you pay a certain amount of money to get the account—

[A pause as Fede’s desk gets bumped.]

Sorry, I’m having a problem at my desk—my wife threw all the mugs onto the table while she was playing a game.

Mike: It’s good you’re referring to her as your wife. It took me a while after my wedding to refer to “the wife”—”my wife.”

Fede: Now it’s my wife. He almost threw it again. But some of these contracts—you pay for a funding test, and if you fail the funding test, you lose all the money. To pass the funding test, you need to make X percent of yield.

Mike: So it gives you an account, and you have to make a certain amount to keep going. Yeah, I think my driver mentioned that too.

Fede: You need to make a certain yield to keep going. Most of them lose, so that’s free money for the one giving the funding. And the thing is, they’re never trading on real money—they’re trading on paper-trade accounts. So the issuer is never losing.

Mike: Got it. It’s like paper trading. So this paper.trade XYZ sounds a bit similar in terms of incentive design—they’re trying to get people to lose.

This is what I love about crypto: any experiment you can think of is being run.

00:16:00 Why Routines?

Mike: Let me do the segue. Speaking of experiments, there’s nothing you can’t do with routines, as we’re finding out. As a trader, it’s important to be able to quickly take data and turn it into something usable. In the past that would take a long time—you’d have to collect the data, clean it, parse it, and finally put it into some visual format you can actually analyze and share.

But with the power of Hummingbot, how it connects every exchange, plus this concept in Condor called routines, that’s gotten a lot easier. We’ve already built a few—Fede has demonstrated them in prior livestreams—but today he’s going to give a real deep dive into exactly how they work and show off the new Condor UI that’s optimized for routines.

Fede: I agree with your description. Anything you can dream of can be built on top of routines. Do you want to share the one you built first—the one for the token—and then I’ll show the new things about routines in general?

Mike: All right, let me make sure I’m running my Hummingbot API and Condor. Let me open up Docker. By the way, I’m trying to make our content a little more clip-optimized. We have a great community manager named Carlio who’s been helping with video production, turning the content we create weekly into something shareable. I’m trying to make his job easier.

00:18:00 Does Hummingbot Actually Make Money?

Mike: Before I dive into the meat of routines, let’s answer a few questions from the audience. There’s one from Digita: “Is there a real use case where using Hummingbot makes money with a growth strategy?”

We get this question a lot. We probably wouldn’t have $30 billion of reported volume per year if people weren’t using it for something of value. But I’d look at Hummingbot more as a framework for building some type of automated process. A lot of market makers use Hummingbot to run strategies like cross-exchange market making or pure market making, because that’s how they provide that service to their customers. Similar to us—when we do market making, we use Hummingbot because it lets us automate something and build off a framework instead of hiring a bunch of developers to build from scratch.

Our job is to make sure it’s usable in many different ways, and that’s why we added Condor. Now anyone can use Hummingbot—you don’t have to be a developer anymore. You can just talk to Condor and it can build what you want.

Fede: That’s something interesting—if there were no people making money, we shouldn’t have 3 billion in trades per month with our framework. So there’s definitely a way to make money with it. But if you’re expecting to just click a bot and make money, I’ll tell you that you will fail, because it’s a framework. It’s not a magic mystery box that makes money for you.

The framework lets you collect all the market data from the exchange—order book, trades, candles, funding rates, everything you need—and lets you execute any trade you want. There are some pre-built strategies you need to configure, and based on the config they change a lot.

So yes, it’s a framework. If you have a strategy that’s good for the type of advantages you have, you can make money. In my case, right now we’re working with a client that has an edge on fiat markets on Binance. We’re trading around 1.5 million per day, and we get 0.015% in rebates. On a monthly basis, that’s about 9% only on rebates—then comes the trading PnL. So it depends a lot on the edge and the type of strategies you want. The point is, wherever you want to use it, you can, because it has all the primitives you need.

00:21:00 Demo: Memecoin LP Yield Hunter

Mike: Let me demo the routine I built a couple of days ago. As you guys probably know, my specialty is doing LP strategies in Solana, especially for memecoins—which I do less of now. A couple of years ago I was doing enough of it that I was personally getting concerned I was developing a slight gambling addiction. So I’ve been building routines to identify promising memecoins and then LP for them on Meteora. Let me share what I’ve built so far.

This is very early, so don’t expect it to be life-changing or some super profitable algorithm. But I thought it was a promising start.

Fede: While you share that—I like a lot what Samuel said in the chat, and that’s exactly the way I’m approaching it. I’m adding a process of batching in the middle, because to be more aggressive, my market maker has an onload period and an offload period. I’m doing discrete trading sessions—some with positive outcomes, some with negative outcomes—but it works long term. There’s a balance between how aggressive you are and how you can keep making profits long term.

Mike: Okay, let me share my whole screen. I have Condor running here. We recently updated the installation section of the website—condor.hummingbot.org. David just added a new installation script, so you should be able to download the script, run it in your terminal, and it’ll install everything you need.

The first step is creating the Telegram bot you’re going to use. I’ve named mine Condor—a new bot I created using BotFather. Because I’m already running Claude Code, it’s connected, so I can say “Hi” and it should respond. There’s also the web dashboard. Let me ask Condor what it can do.

As you can see, it’s a harness similar to Open Claw, and what you can do with it is anything the Hummingbot API is capable of—getting portfolio, doing trading, running bots and agents. But the most valuable thing we’ve seen so far is building routines.

Here’s one I created the other day to analyze pools and create an agent. This routine uses the GeckoTerminal API to fetch the top Solana pools—probably the top one or two hundred pools by volume. Then it ranks them by yield, meaning the fees the pool earned divided by the total value locked. I then filter by concentrated-liquidity pools, because I don’t want to buy the memecoin outright—I only want to set single-sided ranges. If the price falls into the range, I’ll buy some, but I’d rather earn fees. So this routine just ranks the top pools over and over again. When I ran it, the top pools were RKC, Troll, and Hanta.

00:24:00 The Memecoin LP Yield Hunter Agent

Mike: After I built that routine, I paired it with an agent—called Memecoin LP Yield Hunter. The strategy is defined in the agent.md file. It says: provide single-sided SOL liquidity to the top three trending Solana memecoin/SOL concentrated-liquidity pools.

So it takes the output of that routine—the ranking of top pools—and there are three slots. If the slots are empty, it creates LP executors to put single-sided positions in them. The LP executors have automatic close limits—upper and lower. When an LP executor self-closes, that frees up a slot, the routine triggers again, and the agent deploys that capital into a new slot.

I’ve run this for a little bit. This last session ran for 100 ticks. In the beginning, because it was inheriting from other sessions, all three slots were filled. Then it kept tracking the slots. Sometimes it opened slots—here it actually saved an error: at first it failed, then the next tick it detected the duplicate and did the right thing. Although it needs some iteration, it basically did what it was supposed to do—run the routine, look for open positions, and create LP executors on Meteora.

In terms of actual performance, it did okay. I’ve been tracking it on Meteora, and I had positive PnL in basically all the pools I created. A couple are still in range—they might rug and go down—but so far I’m pretty much in the black in all the pools.

Fede: Seems like there’s a problem with the reporting of the executors—the P&L. If you go down to the executors, do you see that they say zero P&L?

Mike: Yeah. Part of it is the candles aren’t being fetched, because it would need to get candles from GeckoTerminal for these. There were a couple with P&L in there. It’s probably easier to see in the executors list. Part of it is that this is SOL—for instance, this one I made 13% on from a yield perspective, but the volume is in SOL, so the P&L is probably denominated in SOL.

But you’re right, I need to check, because there’s a bunch of stuff with the GeckoTerminal data not displaying correctly. I need to make sure the SOL base displays for executors, as well as general DEX charting.

Fede: Don’t worry about that—I can do it for you. The SOL thing is already solved in my PR. On the top right you’ll have a conversion option that lets you do the conversion.

00:30:00 Routines: The “New Reporting Era”

Mike: Overall—and this is for the audience too—my experience is I’ve found routines to be much more helpful and usable right now. The agents I’m excited about in the long run, but routines are immediately valuable.

For example, here’s another routine I created to analyze the existing LP positions I had created. This is the current price, this is my overall position, and these are the auto-close prices for each position. With this routine I could see whether my positions were in range and earning fees, or close to being closed. In the future I’d also like to have a notification if one closes—then it shows me a list of the top pools and lets me select which one the new slot deploys into. That kind of format I’d feel more comfortable running in the near term.

Fede: I think this is a revolution. Routines and reports are the new reporting era—dynamic visualization. You have an idea, you want to plot it, then you want to reproduce it over and over again. It’s amazing.

Mike: This is interesting, Fede—the first time I ran this routine, I looked at the report and thought, “I actually want to see more details about all these positions.” So I asked the agent to add information about each position to the report. The second time I ran it, it added these liquidity distributions for each pool, showing my position relative to the existing liquidity distribution. I thought it was cool how you can iterate on the reports and make them better over time.

Do you want to share what you’ve been working on? I think I’m even using an outdated version of Condor.

00:32:00 Audience Q&A: LP Executors

Mike: There’s a question from Raj: are we able to debug some of the LP executor issues? We have been fixing them. I pushed to Condor recently the updated LP executor guide—that’s on main. There’s also a PR open about the API that our QA team is going to review, which fixed a couple of minor issues I found using API plus Gateway.

Overall, the LP executor should be working from an API perspective. We still need to make sure the Condor UI is integrated correctly. For all executors, my lesson is: if you have it configured correctly, it should work. But you may have to do some work—check the API logs and error messages—to make sure it works.

00:33:00 Architecture: Agents, Routines & learnings.md

Fede: There’s another question from Samuel—a very good one, because it’s about how the architecture works for routines and agents.

We have the concept of an agent powered by an LLM. All the routines—like the ones Mike was showing—you can build with an agent that’s also in the same product. Inside Condor, you have an agent to build the routine that will help you use Hummingbot to surface all the data you want.

The interesting thing is that once you create the data you want, and you know what you’re looking for, that’s automatically available for the agent. So the trading agent you create will be able to get that data and use it to trade.

That agent has tools for creating and stopping executors. While the agent works, at each tick it logs things in its journal and maintains a learnings.md file with the knowledge it gathered. The next time, it’s aware of the problems it had in the past and is able to face them. So it’s an evolving agent that you work with. Plus you can edit these things from the UI—the learnings, the behaviors, everything.

Mike: Right now, what we’re trying to do is create an open standard—a framework where the agent can operate and process data deterministically using routines. It uses tools as executors, so it’s only using the LLM for the actual decision part, which should be much more token-efficient than throwing a lot of APIs and documentation at a model.

So the Condor harness has this concept of a trading agent, which is hopefully a standard for doing something professional-grade where an LLM is involved in helping you do something over time. We still need to discover what types of agents are best suited for this versus traditional bots—which are more for market making and HFT, deterministic and not really suited to make probabilistic choices all the time. That’s why we’ve designed Condor in a very open way. Routines, as Fede will show, are probably the most flexible primitive we have right now.

00:36:00 Condor UI Tour

Fede: Let me put my screen up. Some of the changes we have for Condor. This is the portfolio page—you already know about it, it didn’t change much. The important thing is you have a central place to see all your tokens, the distribution by exchanges, and the variations over time. What I added is this USDT selector that lets you change between different currencies. Probably we’ll remove some and just leave USDT, USDC, and a few others. This uses the rate oracle to translate the values.

Then the trade interface is still working really well. You can run an executor from here—create a grid, a short grid, a long grid. If you’re getting started with trading and want to run some grids, you can run them across all the CEXs. You configure the parameters and the UI works really nice.

Then we have the bots. Right now I don’t have bots running on this account. If you go to the editor, you can see the configs we have. We also have the backtest, but I don’t recommend using this tool yet, because I’m working on a routine that will do it better. I’m very bullish on routines in general.

For example, for the post-analysis of a bot, the best way will be with a routine. You deploy five controllers on one bot; once the bot finishes, the performance of those controllers is the same as before. So once you finish your run, you can process all the databases together and generate the HTML files. The routine result is an HTML file with all the data you want. Once you process one bot, you don’t need to process it again. So having links to the HTMLs is the best way to store the data of a processed bot, instead of querying all the trades and processing them again every time you want to see an old bot’s performance.

This is the executors view—now we can translate it to USDT. If you have multiple bots... the other day in Botcamp we created a pairs-trading agent that creates grids based on deviations, so you can filter one of those.

This is the agents view—the one Mike showed before. If you go to a specific agent, you can see the strategy MD, the learnings, and the routines filtered to that agent. If you run it from here, it generates this output. You have the two versions to move between.

Mike: Fede, did it take a couple seconds to run?

Fede: Yeah, it takes a few seconds.

Mike: You may want to explore adding a loading indicator—that should help. There should be components you can easily design for that.

Fede: “Can I use Condor directly for a grid bot?” Yes, you can. It will automatically clone the Hummingbot API, and in the trade pane, if you pick grid, you can create a grid directly there.

You can also schedule routines—run them every five minutes, every minute. And I improved the error checking. Here it says “Running, zero runs, routine failed.” This is only for failures—if your routine fails, this is how you see it.

00:42:00 Order Book Depth Across Exchanges

Fede: You can run interesting things. For example, this routine—since Hummingbot has access to the order books—you can analyze the different depths of a specific market. As simple as that, we created a routine that analyzes the order books of four exchanges, compares the same price, and shows the different BPS around the price.

Mike: Is it fair to say there might be an arbitrage opportunity between MEXC and KuCoin here, or maybe cross-exchange market making?

Fede: Cross-exchange might be a good opportunity—I’d place sells here and buys here. This is three, almost four BPS of distance, but there’s no arbitrage. To have arbitrage, these would have to be crossed, and that value would need to be bigger than the fees you’re paying.

But this is the power of routines. I used the agent mode to say I want these order books—use a gather to get them and compare the books—and it was able to do it. Let’s see AAVE. Here there’s an actual opportunity: on Gate we have five BPS to sell, and on Binance it’s 0.5 BPS. So there’d probably be an opportunity to make.

00:43:00 Arbitrage vs. Cross-Exchange Market Making

Fede: A good long-term strategy, instead of just doing cross-exchange and making trades only when they arrive and then hedging, would be to sell here and place a limit here—quoting buy here and quoting sell here. That would be a better way to start moving your inventory to one side.

Mike: Right.

Fede: Here we’re talking about mature tokens, but let’s look at a meme coin. This one is only traded on Gate and KuCoin. You can spot opportunities here too.

Mike: I should mention this Protocol coin—I think I was LP-ing for this on Solana. I think it’s a Solana-based meme coin, so there’s probably some opportunity between LP-ing or swapping it on Solana and trading it on a CEX.

Fede: Here you can get 90 BPS of spread. The power is huge—the things you can do are amazing.

Mike: I think I’m going to take this arb-check routine and add a Jupiter leg, and really look at this Troll token for next time. I’m pretty sure the spreads in Jupiter are going to be tighter than this 90 basis points. Since it’s a Solana-made token, the spread on Solana is tighter, so there should be an opportunity to do cross-chain market making—make on these CEXs and take on Solana.

Fede: I’ve now set this to run every one minute, so it’s scheduled.

Mike: I’ll build it off the back of this arb-check routine—I should be able to just tell the agent to modify this one and add the Solana bit.

00:47:00 Agent Tab Improvements

Fede: There are a lot of back-end improvements, and the Agent tab was improved. I still like to use Telegram a lot, but here you can use the different agents—the agent builder, the Condor agent which is your main agent, and the routine builder, which lets you build routines more effectively.

There are a lot of things to play around with—seeing how the books are moving from here. It’s amazing that we can see this on our live reports now.

You can also see the routines that are running or scheduled in the main UI here. I probably need to simplify this nav bar, because when there’s a lot of data it gets collapsed. I’ll probably remove the date from here.

Mike: You can probably also shorten it—show the name and remove the description, because I think the name is sufficient, as long as you can access the name somewhere. It’s already in the sidebar.

Fede: I need to remove these two things.

00:48:00 Color-Blind Mode

Fede: Another thing I added—because I have a friend who uses this a lot and he’s color blind—I added a theme in the portfolio. This theme works for color-blind people.

Mike: Do you do a theme selector, or how does that work?

Fede: It’s just like dark mode, light mode, color-blind mode. You just change this.

Mike: I kind of like that. Basically three modes—that makes sense.

Fede: If not, I was going to do color-blind for light and color-blind for dark, but then I said there are a lot of options and it’s probably not worth it.

Mike: We could build themes, but we probably save that for later. I like this—it makes sense for people who need some visual help.

00:49:00 Wrap-up

Fede: I think this was a very good session to demonstrate this. We can catch up next week with more advances.

Mike: I’ll do some homework for next session. After you merge in the PR, I’ll take the arb-check routine and try to incorporate some CEX/DEX arbitrage checking. Next week I’ll come back and report on whether there is or isn’t arbitrage in the Troll token.

I also want to show that routines aren’t just for you to run—you can modify and extend them, and with the agent it’s a lot easier.

Fede: Thank you very much, everyone, for joining. Next week we’ll see more improvements.

Mike: All right. Bye, everyone.

Fede: Bye-bye.

• Watch the full episode: YouTube

• Register for the Condor Builders Cup: Hackathon

• Install Condor: Condor

Episode Highlights

1:30 Market Discussion: Jito, Orca & OmniPair

The hosts share their recent trades and market outlook. The big news: Jito announced JTX, their new perp DEX. With 80% of revenue going to JITO holders, this could be “the Lighter of Solana.”

“The derivative of the price that was going down very strongly the last months is like getting flat, and now seems like it’s slightly going up. I’m feeling more like in a positive recovery across most of the assets.” — Fede

8:00 Condor Builders Cup Update

The hackathon has been renamed from “Condor Agents Hackathon” to Condor Builders Cup, styled after F1 racing with sponsored teams. The format:

• Teams sponsored by Orca, Gate, Ripple, and Derive

• One slot reserved for the MVP of Botcamp Cohort 13

• Winners compete in a 48-hour live trading competition with real capital

11:00 Complete UI Walkthrough

Fede demos the redesigned Condor interface:

• Portfolio view — See evolution over day/week/month, asset distribution by exchange

• Trade tab — Merged market view with executors (Order, Position, DCA, Grid)

• Command+K chat — Opens an inline Agent chat panel with context on what you’re looking at

“With Command+K you can hide the Agent chat, and with Command+K you see it again.” — Fede

25:00 Backtesting with Plotly

The backtesting page now uses Plotly for interactive charts. You can run backtests from the UI or create routines that generate backtest reports—Fede prefers the routine approach for better visualization.

29:00 Executors Page: Isolated Performance

You can run multiple grids on the same market and see exactly how each one performs in isolation. Fede walks through a live grid on TON that’s generating ~1.9% daily yield from matching buys and sells. He then creates a second grid on the same pair, and you can see the P&L tracked separately for each.

“You can do something pretty complicated, and then still evaluate whether that worked or not.” — Mike

35:00 Bots vs Routines vs Agents Explained

Fede breaks down the architecture:

• Bots — Hummingbot instances running controllers in isolated containers

• Executors — Single order types (Grid, DCA, Position) running in the API

• Routines — Python programs that generate HTML reports with data analysis

• Agents — LLM-powered decision makers that create routines and launch executors

The key insight: agents use routines to see data deterministically (same structure every time) instead of burning tokens on repeated tool calls.

39:00 Routines: Full-Screen Reports

The routines page got a major upgrade with full-screen visualization. Navigate through reports with arrow keys, schedule them to run hourly or daily, and filter by agent.

The chat panel knows which routine you’re viewing—ask “Can you give me the code of the routine I’m looking at?” and it will.

49:00 Agent Sessions & Decision Tracking

When viewing an agent’s sessions, you can see exactly when and why it made decisions. Coming soon: bubbles on the chart showing when the agent was reasoning, with click-through to see the full system prompt and response.

56:00 “Open Source Bloomberg for the AI Age”

Mike crystallizes the vision:

“To me, this is like Bloomberg for the AI age. You want an application that takes advantage of LLMs, but still does the things that a trader needs... look at charts, visualize data. You can also talk to the agent to help you do things, automate tasks, get a better understanding of the data.”

Next Week

More improvements coming, plus continued development on the Condor Builders Cup. Join us live next Friday on YouTube.

Full Transcript

00:00:00 Intro

Mike: Hello. Welcome to the Bot Pod podcast. I’m Mike, this is Fede, and we’re the co-maintainers of the Hummingbot open source framework. A lot of people use Hummingbot to automate their algo trading. We have built a new agentic trading harness called Condor.

This week I’m very excited because Fede has lots of improvements to show off. He’s made a complete UI revamp, and I think now Condor is much closer to a full-fledged trading terminal which can help you execute trades anywhere, conduct research, and because there’s an LLM attached to it, it’s more intelligent than traditional applications.

But before we get into it, I’m starting to see some stirrings of life in the market, Fede. It seems like some tokens are starting to pump.

00:02:00 Market Discussion: Jito, JTX, and Token Picks

Fede: Yeah, actually I regret a lot because I sent you a message saying “Hey, check out this token,” and the next day it was 66% up. I only farmed like $100 in fees.

Mike: Which one was that?

Fede: Jito. They announced JTX, which is this new exchange. I joined the public beta and said, “Okay, I think it’s time to trade this thing.” So I set up a few ranges on Meteora, but suddenly it got into the range, made $100 in fees, but then it went up. It was better to buy and hold, I think.

Mike: Yeah. I think JTX is actually very interesting because Jito has always been one of the leading technical projects in Solana. They still have the majority of market share among the validators. So if they launch a perp DEX, that perp DEX should be the fastest on Solana.

Fede: They will ensure the fastest execution, so I think they will take a lot of the market. I think it’s still a very good moment to buy it because the market cap of Jito right now is almost 200 to 300 million.

Mike: I think the FDV is higher—closer to 500 or 600 for Jito. But regardless, if there’s a Hyperliquid-sized opportunity to build another perp DEX, I do think they can justify the valuation easily.

Fede: That’s an interesting point. With Hyperliquid, it’s the best place to trade perps, but the HyperEVM—I don’t think they’ll get too much adoption. I don’t see too many people using it. The clear blockchains that people use are Ethereum, Base, Solana.

Mike: Yeah, I agree. HyperEVM has not been a huge success. But I do think HIP-3 has been, because now with all the RWA markets there’s a clear shift from CME over to Hyperliquid because you can trade 24/7.

But if JTX can get the same level of open interest or even approach Lighter in terms of volume and open interest, I do think it can easily justify the valuation. I think at least in the near term, there should be an opportunity to build the “Lighter of Solana”—the main perps DEX that people in the Solana ecosystem use.

00:05:00 Token Picks: OmniPair and ORCA Trade

Mike: My token pick this week was actually a much smaller token—also a DEX. I started a new position in OmniPair, which is a Meteora-style DEX, but you can lend and borrow against your reserves. The idea is that if you create a pool and deposit a position—let’s say MET/USDC—now you can borrow some USDC against it and do something else with it.

I think it’s interesting. It’s also a very low market cap. But I did actually make a decent profit off it because basically as soon as I bought it, they announced a raise. That token also jumped 30-40%.

Fede: Oh, nice.

Mike: Both of us like to look at these new exchange tokens because our day job is integrating exchanges into Hummingbot.

Fede: Yeah. Last week I was holding my ORCA position. On Sunday, I sold all of it.

Mike: Great trade.

Fede: Not all of it—I left only like 10K on ORCA. But I made probably 120-130% on that trade. Nice trade, yeah.

Mike: Your exit timing was incredible because I think you caught the very peak.

Fede: It was all luck because my assets were released at that time. When the assets were released, I just said, “Okay, I’ll leave this 10K here and the rest will be all in.”

Mike: You still bought ORCA when it was a lot lower than it is now, so the entry was not luck. But the exit timing was probably lucky.

00:07:00 Market Sentiment

Fede: And the other thing is that I’m waiting because MET is coming, so get ready for MET.

Mike: We’re supportive of all DEXes, but I think as we showed in the podcast last week, if you use fundamental analysis, it looks like Meteora from a revenues-to-market-cap perspective is trading “cheaper” on a fundamental analysis than the other DEXes.

Fede: One thing that’s interesting—I’m seeing some news about the price of Jito. Seems like the JTX trading app is going to redirect 80% of the revenue to JITO holders.

Mike: That makes sense. That’s probably why the token’s accruing. Before, it wasn’t really clear how token holders would benefit from Jito doing stuff. And now it seems they actually will benefit if the exchange gets volume.

Overall, I think the market is recovering. It’s consolidating now. I feel like it’s tested the support at 80 a few times for SOL. Bitcoin has recovered to 81K now. So it seems like the market is on more of an uptrend.

Fede: I think that the vibes are bullish.

Mike: Not financial advice.

Fede: Yeah. But I’m feeling it. The derivative of the price that was going down very strongly the last months is getting flat, and now it seems like it’s slightly going up. I’m feeling more like in a positive recovery across most of the assets.

Mike: Me too, definitely.

00:08:00 Condor Builders Cup Hackathon Update

Mike: So let’s get into the meat of the presentation for today. We have a lot to show off in terms of the new Condor UI, but I also want to give an update on the hackathon that we’re planning for this week. Let me share my screen.

Last week I think it was just called the Condor Agents Hackathon. Now we’re going to call it the Condor Builders Cup, because the idea is that it’s not just a hackathon. The initial phase will be the hackathon, and we’ll set up a sandbox environment for each winner. Then we’ll run them in a regimented race for 48 hours.

We’re trying to style it after F1 or racing where there will be teams. The teams will be sponsored by exchanges like ORCA, Gate, Ripple, and Derive. We’ll also have one agent slot for the MVP of Botcamp Cohort 13. We have about 20 to 30 students going through the cohort right now, and the winning strategy from Botcamp will represent Hummingbot in this competition.

But we’ll have at least five other slots that you can apply your agent to. Agent submission will start in about two weeks. You can already register and write something about what you want to build. We’ll also try to allow people who join the hackathon to find each other and perhaps collaborate on the agent.

Fede: We have a lot of good prizes, I think.

Mike: I think the sponsors have already committed something like $15,000 or $20,000. We’ll put up capital for the agents from all the sponsors, and people can really demonstrate what they can do with real capital in their strategy.

00:11:00 Condor UI Walkthrough: Portfolio View

Fede: Yeah, I think today I’ll walk through all these things, and it will be really nice to see what we built. I’m currently working on it, so there are still some things to improve, but overall I think I can just share screen.

Can you see my screen now?

Mike: Yeah. We have about eight or nine people on YouTube and probably a few more on Twitter as well. If you guys have any comments or questions, just let us know. No question is too basic.

This is the Condor UI now, but this actually looks a lot different—a lot better actually—than the version that I’m running on my computer.

Fede: Yeah, it looks much better than the other version. When you start Condor, you just go here and click on web. We give you this link where you can access the web dashboard.

On the main screen, we always have the portfolio evolution. This graph was below before—now it’s everything more compact. This is the page where you see almost everything. You can change the visualization to see the last day, the last week, or just see the last month.

If you see this view, you’ll see the proportions of assets that you have. This is quite useful—let me show this specific case where we see the evolution of the assets when we’re doing market making.

Mike: So did you just switch to a different API server?

Fede: Yeah. Here you can pick different API servers. In case you have multiple clients, you can have one Hummingbot API for each client, and you can switch and just start seeing the other data.

You can see the proportion of assets for each exchange. Where is the distribution? Let’s say I want to see Binance—how much we have from each.

We can add the API keys and servers right away. You can add a new API key—let’s say I want to add a new one for Bitget. Here you can put the data that you need, and you’ll add the credential.

For Gateway, it says it’s running, so you can restart it. You can pull the latest gateway image. I’m going to add a comparison between the current image you have from gateway with the latest image available, so if there’s a chance to upgrade, it appears here easily. And here you can also see the logs.

Mike: Okay. Can you also update the Hummingbot API Docker image as well, or just on the server side?

Fede: That’s something I’m currently working on with the update command. If you run update, it will check first if it’s up to date or not, and if so, it will let you push and build a new version.

00:15:00 Trade Tab and Executors

Fede: There’s a question that says, “Does Condor or Hummingbot come with predefined bot strategies like grid trading?” And yes, obviously. Let me show you.

If you go here to the main page to trade—currently I’m running a grid. This is a grid. As you can see, it’s an executor. There’s a distinction between executors and bots. The executor is just like a grid, for example. A grid is an executor. And a strategy will be a combination of multiple executors.

For example, there’s a strategy that will place multiple grids depending on different conditions—that would be more like a bot strategy. In this Trade pane, we can only create executors.

Mike: Yeah. So these are kind of like order types—almost like a basic order type and an advanced order type, right?

Fede: Yeah, that’s the way. Here you can pick between these different executors for trading. Order will be just buy and sell, but keeping track of your average buy price. Position will be more like, okay, I want to have a take profit of 5% and a stop loss of 2%, and I want to put $10. This will create another executor here to trade with this style.

You can also pick DCA and say, “Okay, I want to have this level and this level, and between these two things, I want to have a take profit of 5%.”

Mike: Okay, got it. So it appears on the chart.

Fede: If you click on this panel, you’ll see the order book, and we start streaming the trades via WebSocket also. This is the Trade pane.

Mike: Yeah, you can get exchange data. That’s actually a feature I wanted to show. Nice.

Fede: There’s another question: “Do we intend to add other executors like arbitrage and cross-chain market making?” We have those executors actually, so we’ll probably add them, but we need to think a little bit more about those views because that involves two markets. Those executors might need a specific visualization.

Mike: Yeah. The other thing is this is just a web dashboard, but you can also use the Telegram bot to launch executors there as well. These visualizations are really intended for single-market executors. When we do multi-market executors like arbitrage and XCM, we’re not quite sure how to visualize it yet. For now, I’d recommend just deploying them directly using the Telegram bot.

00:19:00 Command+K Chat Integration

Fede: Talking about agent chat, I’d like to introduce—with Command+K, you have this chat pane where you can just pick Condor. Today I’ll add the voice mode, but as you can see now, we have the chat inside the web UI.

So here I can ask “what executors do I have running,” and this will be using the same style as we’re using on the Telegram chat. The whole product is getting more homogeneous.

The other cool thing with the dashboard is that now in routines I’m able to inject some data of the dashboard into the chat. If you’re looking at a routine, there’s actually an HTML in the context I’m passing to the chat saying “the user is looking at this specific file.” So it’s an easy way to start integrating your chat experience with your visual experience.

Mike: Yeah. I think that’s going to be really powerful because the chat’s great for doing stuff when I’m not in front of my computer. But in front of a computer, like most traders, I want to see the charts, I want to see everything visualized.

But there are certain cases when you still want to do things in chat—maybe you want to ask a question. Being able to see the chart for some token, having the chat up, and just asking questions like “what has happened recently to this token” or “why did the price go up”—that kind of thing I think is a really powerful combination.

Fede: Also here in the chat you can open multiple chats. I can keep two conversations on different sessions. You can say something like, “Based on the candles of the last day, can you tell me what are going to be the potential prices that the market will go?”

And you can also trigger executors from here too. With Command+K you can hide it, and with Command+K you get it again. This experience is good. I’m using the light theme but it also works with the dark theme too.

Mike: Yeah. I think some people prefer dark, some people like light. I just switch back and forth depending on the day or night.

00:23:00 Bots Page and Editor

Fede: Let’s move to other panes. For Bots, we have this bots running page. Let me switch so you can see what it looks like. This pane shows the bots running. We’re running 14 controllers in one instance. This is a good thing about being able to run different bots and see the different volume they generate and the different P&Ls.

You have the Editor where you can change controllers, add controllers, or whatever. You can also use it to visualize the configs that you have. We have 68 configs for PMM Mister. Here you’re modifying the YAML. You can also create a new config from a specific controller if you want, upload a YAML file, or paste directly the YAML file that you want.

If it’s a controller that you want to add, you can add the controller by type. Once you pick the folder, you pick the name, and you can just add it.

00:25:00 Backtesting with Plotly

Fede: Then we have the Backtest that I think we saw last time.

Mike: Yeah, but the UI looks much better than last time. Actually, can you do a quick backtest just to show it again? I think this is a really impressive aspect. Backtesting is something that everyone wants to do, but there are very few tools—let alone open source tools—that allow people to really do it. Here we’re actually using the historical data directly from the exchange to conduct a backtest for you. This works on any controller that you create that uses executors.

Fede: There’s a question that says, “How do you choose the symbols for backtest?” It’s in the config itself. The config I was just using has the symbol selected.

Mike: Yeah, so if you go to Editor, that’s where you create the configuration for a controller. When you do the backtest, what you’re doing is passing that configuration. You’re basically selecting configuration, and the configuration contains the trading pair and other parameters.

Fede: The controller is what you can backtest—it’s the code. Here you can see the controller config. You define all these things like candles connector, controller name, all that stuff. You need a YAML file that uses this configuration or gets values for all these configs, and that’s what you backtest.

I already have that for MACD BB JITO. If I want to do it for another one, I can copy this, add a new one called MACDBB MET, change it for MET, and upload it. Now if I go to backtest, I can backtest the MACDBB MET. But why do we need to do it manually when you can do it with AI? Now I’ll show you how to do that with AI.

00:28:00 Mike on the UI Progress

Mike: But yeah, before you move on, I just want to say this is basically a full-on replacement—it’s actually even better than the previous dashboard we had in Hummingbot. Before, we had an application that was just designed to do this particular phase: deploying bots, backtesting them, and running them.

But now, because you also want to do other things—research, trading—it’s one tab in a larger application. We think this harness, this Condor harness, is designed to do everything that a trader might want to do. You may want to do trading, run automated bots, but you also might want to create other types of things like a routine or an agent. That’s what Fede is going to demo now.

00:29:00 Executors Page: Isolated Performance Tracking

Fede: Then we have the Executors page. We added these filters—three months, one month—to see overall performance. Here we can find the executor that’s currently running. You can create a new one from here or export this data as CSV in case you want to analyze it.

If you click on one of these executors, a left pane will open with more detailed information about this executor. For example, this is a grid that I started yesterday just to test how it would behave—a long-term grid on TON.

I found some really interesting things. I paid $4 in fees and the P&L is -3.25, and right now I’m in a lower price from where I started. That means at some point the grid was making profits because otherwise I should be in another position, right?

As you can see, if you navigate all this information, there’s some custom info that the grid shows. The realized PNL quote was $8.30. So I was actually making $8.30 after paying $4 in fees. That’s why this value is +$4. But why am I having -$3? Because I’m holding a position size of $300 and it’s down from the original state. That’s why the final PNL is negative.

Mike: So overall it’s a very—so that’s unrealized PNL of the grid?

Fede: It’s unrealized. The grid is buying and selling. All these trades that appear here are buys and sells of that grid—it’s actually doing its work. What this will do is hold all this position. Up to this value we should have $500 worth of TON. Right now I only have $300.

But the interesting thing is that it made realized $8 here. If I did $8.3 and it’s been 20 hours, let’s say 21 hours... Let me calculate: 8.37 divided by the hours, times 24... that’s $9.84 actual realized, divided by the 500 allocation, times 100. That’s 1.9% yield that the grid is generating per day.

Mike: Okay.

Fede: So if the market stays inside these bounds, I’m making 1.9% per day. That is a lot.

Mike: So assuming the P&L is consistent for this grid, right?

Fede: That’s the point. I’m making 1.9% without counting the P&L of the position. It’s just 1.9% of matching buys and sells. That means that if the market recovers to the original price, I’ll be zero on position, but I’ll have this amount of realized P&L.

Mike: And you’re also trading this on an account with full fees, right? You’re paying full fees on this account?

Fede: Exactly.

Mike: So this would be even better with lower fees. To me, I think the best part about this is that you can isolate a pretty complex strategy like a grid and isolate all the trades in it and just be able to analyze what happened. Because if you look at the Binance interface, it’s really hard to separate what happened—it’s all together. Here it would be hard to tell exactly how one isolated grid performed, but in the Condor interface, this is really cool.

00:33:00 Running Multiple Grids on the Same Market

Fede: Yeah. Another thing is you’re not taking into account that here I can be running other grids on top. So that’s when things get complex. Let’s say I want to deploy another grid on this specific market.

I can be running two grids. Let’s say I’ll auto-fill and I’d like a short grid here. I’ll put only $200 and a take profit of 7.5. If I create this new grid, now I have two grids running here.

See that now there’s a green thing appearing here—it’s because this other grid is just getting started. Until I have a few more records, it will look like the other one later on. You can see the P&L of this grid and of the other grid separately.

Mike: Nice. I think this isolation is actually really cool because now we can do something pretty complicated and then still evaluate whether that worked or not.

00:35:00 Bots vs Routines vs Agents Explained

Mike: Can you just quickly walk through what is the difference between a bot, a routine, and an agent?

Fede: Yeah. A bot will basically be a running Hummingbot instance—the original Hummingbot that we know from the CLI—with a set of controllers. One bot can have multiple controllers inside that can be trading on different markets. But you deploy all in an isolated container.

The executors that you deploy from here are going to be running in the Hummingbot API as part of the API.

Routines are just Python programs—very simple Python programs—that do something and generate a report. When do you use routines? In a lot of scenarios: market data analysis, reports about your operations, discovery of potential markets that you might want to trade, notifications when something happens. There are a lot of different use cases for routines.

Why is it so cool? Because it’s just Python. It’s just a Python file that you can run, you can schedule, or if it’s continuous, it has a while True and will be doing an update. But it’s a very simple Python file.

The main thing is that it will probably always use Hummingbot API for all the market data because we have connectors with 50+ exchanges. You can get order books, trades, OHLCs, funding rates. You can get from the Gateway the distribution of pool liquidity. You can get from GeckoTerminal the candles. All those things are part of the core Hummingbot API things that you can do using the routines. But you can also query any other data source because it’s just Python.

Agents are where the LLM comes in. What I like a lot about organizing routines by agents is that for now we have trading agents, but maybe there can be assistant agents that are more like assistants for market data. So it might be interesting to consolidate all the routines of market data into an agent that’s more like a market data analysis agent.

00:39:00 Routines Page: Full-Screen Reports

Fede: Now let’s move to Routines. That’s probably the biggest improvement on the layout.

Here we have filters on the top that says Routines. These are the general routines that appear in the main folder. And we also have the routines from the agents—routines created in a specific agent.

For example, if we see the routines of Brigado, there are a lot of routines comparing the BRL market that I’m personally using. If you go to this market cap comparison, this was the one we did last week.

Now we have the full-screen view of routines. Why is this full screen? Because I think when you’re reviewing routines, you have to be in the mood of “okay, I’m more in a dashboard mood,” where you’re just reviewing the routines. As you can see, it’s the actual output that you generate.

You can configure it from here and run it again if you want. You can schedule to run it every day or every hour. And this is really nice—you can see it says 25, 23 hours ago. If we run this one, we’ll have another observation.

If you press left or right arrow, you can move through these different routines. You have keep track of all the history of these reports.

Mike: So the routine is something that generates a report every interval?

Fede: Exactly.

Mike: How do you see the code of the routine? Is that available here or do you have to go to the file system?

Fede: The code of the routine you need to go to the IDE currently. I think the agent should be able to give it to you. This is another cool thing—if you’re in the process of having an agent working on a specific routine, the data will be injected into the chat saying “the user is looking at this specific report.” So the agent will know what we’re looking at.

Let me ask: “Can you give me the code of the routine that I’m looking at?”

The user is viewing a report from routine called Solana DEX Comparison. Let me read the code...

Mike: I do think having this agent have context is really important because otherwise we may need to add a “show code” button into this UI. It means we don’t need to cover every base in the UI because the agent can answer any questions the user has.

Fede: Yeah, and also being able to modify the routine and see the output—this is something really cool.

00:43:00 AI-Assisted Backtesting

Fede: Let me show you—I’m looking at this backtest chart. I prefer to backtest as a routine to see the Plotly rather than the other UI. I’ll say, “I’m looking at the backtest chart for MACD BB Jito. Can we run the backtest for MET?”

He should be able to understand, okay, the guy wants to use this routine and run this backtesting routine over another pair.

Mike: So it’s using the configuration we created earlier in the podcast.

Fede: Yeah. It says “no Condor data available for MET USDT on PERP.”

Mike: It’s probably a timing issue. The time range.

Fede: Let me see. Let me try: “Can you create a new config to run the same strategy in TON USDT? Plus, I want a backtest for the last three months in one-minute resolution.”

Mike: Let’s try to answer this question from Rooftop while we have it. He asks, “When should we use the Condor default agent and when should we use a Claude agent?”

So this actually is using Claude behind the scenes. But I think his question is probably more around—in agent builder mode in Telegram, it allows you to select the agent, right?

Fede: You can change LLM. We just added OpenRouter. Basically there are a lot of free models, but you need an API key.

Mike: So maybe the question is, when you change LLM, is that changing the LLM used by all agents? For instance, if you change to OpenRouter, will this agent here also use OpenRouter?

Fede: Yeah.

Mike: Okay. So changing LLM is basically changing the model you’ll be using for agent calls throughout the application.

Just to clarify for folks out there—the design of Condor is similar to Open Claw in that it uses some existing LLM you already have. Right now we’ve tried to make sure it supports Claude really well. Through the Change LLM menu, which is only available on Telegram for now, you can change to other models like OpenRouter, Gemini, Codex, et cetera. And then whichever agent you pick, it’ll use it. In the future, we’ll probably add this to settings as well.

00:49:00 Agent Structure and Sessions

Fede: Let’s go to the Agents page. I also redesigned this page to be more consolidated. If you want to see strategy or learnings, you go here—you have the strategy MD and the learnings. If you want to see the routines, you can go here and it’ll open this view that is a full view of the routines filtered by the agent.

The key concept is this: why do agents have routines? The answer is that you don’t want the agent to do over and over again all the tool calling, data processing, and everything. What you want to do with the agent is help him create a routine that will give him the necessary data to take decisions.

For you, you have a routine that you can visualize what the agent is looking at. So there are two things here: you know what the agent is looking at, and you know that it will be the same structure every time. That’s the deterministic part. And once the agent writes it, he can reuse it over and over again.

Mike: Yeah. The way I think about it—the executors and the routines help you put together the agents. The agent is really just something that’s going to create routines to process the data it needs to make a decision, and then once it makes a decision, what is it trying to decide? It’s trying to decide which executors to run, which ones to stop.

Hopefully through using the Trade tab and launching executors, you have a sense for what each executor is doing. Through routines, you can build standalone routines, and then you can combine them and say, “Let me create an agent that’s going to create routines and launch executors.”

Fede: And then the last thing to show here—you have the P&L curve over the different dates, and here you have the Sessions. If you want to analyze what the agent did, you can go to the session itself. It will load the historical candles of that session and show you where the executors were.

What I’m going to add is a bubble here on top of the chart with a brain icon that shows when the agent was reasoning or taking a decision. With that, you can see the output—the agent response—in a bubble. If you click to see more details, it drives you to this view where you can see not only the actual agent response but also the system prompt that entered at that time if you want to analyze something special.

00:56:00 “Open Source Bloomberg for the AI Age”

Mike: Yeah. This was a lot of progress since last week actually. The UI is so much better. I’m actually getting a good feel for how to describe this product now.

I used to work in finance, and in finance, every trader gets a Bloomberg terminal. A Bloomberg terminal is this thing that allows you to collect data, see all the markets, but also place trades. It’s like all the information in a box that does everything you need as a trader.

To me, what this is—this is like Bloomberg for the AI age. Now that you have AI involved, you want an application that really takes advantage of LLMs, but still does the things that a trader needs. A trader wants to look at charts, visualize data, but you also want to talk to the agent to help you do things, automate tasks, get a better understanding of the data.

So to me, what I think we’re building here is open source Bloomberg for the AI era. I can see myself really using this product and saving me a lot of time and effort—just like you’re doing when we’re market making for customers.

Fede: Yeah. I think it’s getting really like covering all the capabilities that you need for an AI tool that helps you do trading. And the good thing is it’s closing the gap for users that want to start doing algo trading. They don’t understand very well the basics or how everything works, but they can easily talk with an agent and do what they want. I can know nothing, but just have my agent talking with... I can just talk with the agents and get an explanation of what is happening, what I’m doing, why this is positive, why the other one is negative.

00:59:00 How to Update Condor

Mike: Last question from Rooftop. Let’s try and answer. This is a very good question: how do people get their hands on this new version of Condor?

Fede: Yeah, this new version—I think I still need at least one or two hours. Give me one or two hours. I want to clean up a few more things because it’s a big PR that I’ve been working on almost half of the week—four days.

So I just need to close a few more details, and then everything will be in main. Once it’s in main, if you go to your Telegram bot and you run update, this will check for the updates and compare your local branch with the current branch. And then it will let you do the upgrade and will restart Condor automatically.

So I think that’s a very good process. You just need to be in Telegram, and Telegram will handle all the complexity of updating your version.

If it says it’s updated in less than one hour, you can just say “Okay, pull the new version” and see if it works. If it doesn’t work, just go to PyCharm and run git pull, then stop your process and run make run again, and it will work.

Mike: Nice. I’m really excited to see what people can do with this now—what kind of routines they create, what kind of agents they create. I think this version’s going to be a game changer.

01:01:00 Live Grid Demo

Fede: Yeah. This grid that we just created is in profit right now.

Mike: Oh, nice.

Fede: But this is because it’s not making profits from the buys and sells that much—it’s making profits because we started here and now the market is here. That’s basically why. In realized PNL it’s only like 50 cents. And the net PNL is $1.67.

But this is like showing you, okay, this is what it looks like to run a grid on another grid in the exact same market. These are the same markets, but the good thing is you can see the difference between running one grid and the other one.

Mike: Being able to isolate the differences I think is really cool because that’s something that’s hard to do at the exchange level unless you’re doing all this manual tracking and computation. So this is going to basically allow you to do all these complex order types, see exactly how they perform, and then also create agents that’ll be launching these order types based on routines they’re creating.

01:03:00 Wrap-up

Fede: Thank you all for being here. You help us a lot. If you repost our tweets, if you tell your friends “Hey, watch this live stream,” or if you tell other people “Hey, try to use Condor”—because we’re trying to make this as big as we can for the community.

Mike: Right now it’s completely free and open source. There’s really no reason not to try it. Eventually we may figure out how to monetize from this, but right now we’re just making it available open source, just like the rest of Hummingbot, because we just want your feedback on how it works.

Fede: Yeah, actually it’s all free, guys, so go and use it. And if you want to give us donations, you can do it, yeah.

Mike: We are trying to make sure this product works for both individual algo traders and for firms. We ourselves are using it for market making for customers. Our hope is that—this is why we added multiple servers, we added Telegram—that even if you’re a real market making firm, this is a professional-level product that you can use and rely on.

Fede: That’s all from me. I’m personally very happy for this change that we’re having on Condor. Probably the worst thing that we had in Hummingbot was the user experience. With this, I think we’re closing that gap. Democratizing open source algo trading—that’s actually what we all want.

Mike: Yeah. I think the structure is starting to come into place. We have the main things you can do with this application already: you can do trading, you can create bots, you can create routines, and you can create agents. Hopefully all the things will work together and it can be something you can rely on, save you time, and you can analyze anything you want to analyze, trade anything you want to trade.

Fede: I think the routines feature will get a lot of adoption, mainly because you can get data sources from everywhere that you want and present it in whatever you want. Basically it’s the first thing you’re probably going to do when doing trading, right? “Okay, I want to follow these tokens and see this information.” Agent, create a routine for me.

Mike: Okay, cool. Thanks guys for tuning in and asking questions. We’ll be back next Friday, same time, and hopefully we’ll have even more new stuff to demo next week.

Fede: Okay.

Mike: All right. Bye, everyone.

Fede: Bye bye.

Watch the full episode: YouTube

Register for the Condor Agents Hackathon: Hackathon Registration

Give us feedback in Discord: Discord

Episode Highlights

1:45 Condor Agents Hackathon Announced

The big news: Hummingbot Foundation is launching its first-ever agentic trading hackathon, and registration is open now.

Here’s what makes it different—the winning agents aren’t just for show. They will be run in a sandboxed environment with real capital in a 48-hour live trading competition to win prizes provided by sponsors including Ripple, Gate, Orca, and Berkeley Street Capital.

“This is the first time someone has tried to put together an agentic trading hackathon plus competition, and I think Condor is the right place to do it because with Hummingbot, it gives you a really big surface area to build upon.” — Mike

The hackathon kicks off in three weeks with workshops on building on XRPL and working with quant hedge funds. Submissions close about a month later, and then the real competition begins.

8:00 Condor UI Improvements

Fede walks through several quality-of-life updates in Condor:

• Market tab merged into Trade tab — Everything in one place now

• New Editor page — Manage controllers and configs like an IDE, upload files, create from templates

• Improved Bots page — See realized P&L, unrealized P&L, volume, age, and logs at a glance

• OpenRouter integration — Cheaper API calls and access to more models, including free options

9:30 New Reports Feature

One of the most practical additions: routines can now generate HTML reports with interactive charts instead of just sending images to Telegram.

“The thing is that I have this picture, but I cannot zoom in. I can see it, but it’s not as good as an HTML. So now if I go to reports, the HTML was generated, and I can zoom in and understand what is actually happening.” — Fede

Reports are stored automatically (up to 30) and can be scheduled alongside your routines. When an agent runs a routine, you can see exactly what data it was looking at when making decisions.

28:00 Live Coding: Token Research Routine

Mike and Fede build a research routine from scratch comparing three Solana DeFi tokens: ORCA, MET, and RAY.

The goal: pull market cap data from GeckoTerminal, fee revenue from DeFi Llama, and generate comparison charts—all in about 15 minutes of conversation with Condor.

“Before, this would be like going to a Jupyter notebook, trying to make it manually. And now it’s just talking there and receiving a picture with the output.” — Fede

The analysis revealed something interesting: Meteora is generating more fees than ORCA but trading at a lower market cap. A potential long MET / short ORCA opportunity may be lucrative.

53:00 Voice Commands Demo

Fede sends a voice message to Condor via Telegram:

“Create a grid executor on ORCA to go long between 1.9 and 2.02 with $300 and a take profit of 0.15%”

Condor transcribes the audio using Whisper (auto-downloads on first use), understands the intent, and creates the grid—all in seconds.

“I really like the experience of just talking because for me, it’s like I much rather prefer to talk rather than write. And it’s like now I can say, ‘Can you tell me the state of that grid?’ and it will just tell me.” — Fede

Next Week: Agent Structure Deep Dive

Now that routines and reports are working, Episode 6 will dive into agent structure—how to edit and iterate on agents as they run. Mike and Fede will continue developing the ORCA/MET/RAY strategy, potentially using the LP executor for concentrated liquidity positions.

Join us live next week on YouTube. Drop your questions in the live chat—we answer them on stream.

Full Transcript

00:01:00 Introduction

Fede: We were having very good results with an operation we’re running with my friends. I also played a lot of padel and I won all the matches that I played last week.

Mike: Unfortunately, my days of winning basketball are over. I’m just trying to stay competitive and play with the old people and the kids.

Let’s get into it. Before we get started with Fede’s part of the live stream where he’ll cover the new changes in Condor, I want to introduce the hackathon that we’ll be starting pretty soon. Let me share my screen.

00:02:00 Hackathon Announcement

Mike: If you go to this link here—I put it in the YouTube chat already—this page describes the hackathon and the schedule. As you’ve probably seen in the previous versions of this podcast, Condor gives you the ability to create agents, which are basically strategies you describe in a strategy file that uses an LLM to help you execute trades based on what it observes in the market.

Our hope is that these agents can be actually intelligent and help you maybe run bots or manage a bot better than a deterministic, simple controller or script can. We’re still building the framework, but we think people can already start building agents using Condor.

Starting in a few weeks, we’ll be launching this hackathon for trading agents. We have some sponsors already: Ripple, Gate, ORCA, as well as a quant hedge fund called Berkeley Street Capital. We’ll be onboarding a few more sponsors as well.

The way it works is that people will be submitting agents, and then the winners of the hackathon will be run in a sandbox environment with real capital in a trading competition, so we can really evaluate how these hackathon winners actually perform in the real world.

We’ll have about a one-month period when the hackathon kicks off. Right now, registration’s already open, so you can go to the website and register. You’ll be able to see the list of other participants. We’ll be providing participants with more information to help them flesh out what they’re building and find collaborators among all the participants.

The actual kickoff will be in three weeks. You’ll be able to submit your agent, and we’ll have various workshops over that time to introduce you to building agents using some of our sponsored exchanges and protocols. We’ll have one for building on XRPL, another workshop for looking at the inner workings of working at a quant hedge fund, hosted by our sponsor Berkeley Street Capital.

We’ll have maybe one or two more workshops as we flesh out the schedule. The submission deadline for the hackathon will be about one month after it starts, in June—right now it’s June 21st. After that, we’ll judge the hackathon winners based on the demo they provide, the code, and the video.

Once we select the winners, we’ll take them and run them using Hummingbot instances with real capital, and evaluate how well they actually perform over a 48-hour period.

We’re pretty excited about this because this is the first time someone has tried to put together an agentic trading hackathon plus competition. I think Condor and Hummingbot is the right place to do it because with Hummingbot, you have a really big surface area to build upon.

You can build any type of strategy running on any type of CEX or DEX, and with the Condor agents framework, you can just use natural language to create that strategy. You don’t need to write lots of complex code anymore. We’re hoping we’ll see lots of good submissions from the hackathon. We’ll evaluate them and work with our sponsors to select the best strategies for each category, then basically pit them against each other in the trading competition.

The whole thing will wrap up in early July with the final competition winners announcement, but we’ll also have a separate hackathon winners announcement before that.

Registration is now open, so you can register, submit your email, and we’ll have a mailing list that provides more information. When the hackathon starts, you’ll be able to flesh out your agent here.

That was my part of the announcement. We’ve also started working on version 2.15, the next version of Hummingbot, which has some base-level improvements. Fede is already building some of those improvements into Condor because we want to make sure you’re able to use the latest changes we’re making.

Fede: Yeah.

Mike: So—

Fede: There’s a question that says, “Do we need to risk some money or do you fund our strategy?”

Mike: Yeah. The idea is we would provide the funding for the strategy. We would take your code—you specify which exchange you’d run this on, all the parameters that go into it—and then we’d run the strategy along with others using the same amount of capital to evaluate it.

This is actually a good question. Do we need to risk money or do we fund the strategy? Basically, we would work with our sponsors to select the best strategy that fits their categories.

Fede: There will be a selection process because probably we’ll have a bunch of submissions, right? First, we’ll filter which are humans and which are agents, so we just let humans participate—that will probably be the filter with the video. Then from all the strategies submitted, we’ll have an initial filter of “these ones will advance to the next round,” and the finalists will be available for the competition. Then we’ll run the bots with the capital.

I think this is a very good initiative. I think people would like to see bots competing against each other.

Mike: Yeah.

Fede: Do you want to start checking the new things in Condor?

Mike: Yeah, why don’t you give people a sense for what’s new.

00:08:00 Condor Updates Overview

Fede: Basically, there were some things we were working on this week. First, the feeds for candles and open interest on Binance Perpetual were broken. I just fixed them and pushed the update—the library is released again. You’ll need to update your Hummingbot API to have this fix because the WebSocket contract changed from Binance Perpetual.

There are also some improvements on the configs on the Hummingbot API side. Plus, there was a redesign on Condor. We merged some of the pages—the market page is now merged into the trade page. We also improved the bots page to have the configs more like an IDE inside the website.

The WebSocket integrations on the frontend were improved, and the backend layer is much better now because it shares data for the Telegram bot and the web UI through one centralized place.

I also added a new feature called reports. I think you’ll like it. I’ll showcase a few now. Basically, when you run a routine, that routine can send you a Telegram message with a picture, respond to text, do all those things we already know how to use.

But we’re just one more step away from creating a report. So I said, “Let’s see how a report feature would look like.” I already made it. When you instruct a routine to generate a report at the end, it will generate an HTML with graphs and markdown—whatever you have there. You have a buffer of maximum 30 reports, and the old ones get cleaned up.

If you schedule a routine every day, instead of sending via Telegram, you can just have the report being generated and go to the website to check the status there. But let’s see them in the UI.

Mike: Yeah, let’s take a look.

00:10:30 Reports Feature Demo

Fede: Can you see my screen now?

Mike: Let me add it to the scene. Yeah.

Fede: We’re going to have some fun in Condor. I’ve been playing around creating a strategy. This was just 15 minutes talking with Condor, with the agent builder, saying “I want to do some research on Bollinger Bands on ORCA. Can you get the candles of one minute for the last two hours and generate—when it goes below the band, above the band—what’s the percentage of this band? When it’s increasing, the value will increase and decrease. I’d like to see the compression or expansion of this band.”

So if the band is increasing, this will be increasing. Here the market goes down, there’s a trend, this band is expanding. Here it’s getting contracted, then expanding again.

Before, this would be like going to a Jupyter notebook, trying to make it manually—I’d say two years ago. Now it’s just talking and receiving a picture with the output.

Mike: Can you show how you generate this? What was the message?

Fede: Yeah, we’re going to generate a new one during this session today.

I also said I’d like to evaluate the volume of the market so I can see volume spikes. Actually, I want to see buy pressure and sell pressure. Here in the first part, the buy pressure was very negative. But this is the second iteration—the first iteration was something more like this, where we spot volume spikes.

Overall, there’s a lot of potential in receiving data here. But before seeing how we can generate one of these, let’s see the new interface of Condor.

00:13:00 UI Walkthrough

Fede: The portfolio page is the same that we had before. I’d like to keep this one simple because it’s just seeing your portfolio stuff.

There’s a question: “The indicator values—volume bands—are calculated by Condor?” Yeah, they’re created by Condor. I’m going to show you how you can see them and create your own indicator. The good thing is you can create an indicator—you can even get a Pine Script from TradingView and tell Condor, “Hey Condor, translate this Pine Script code into Python code to visualize it in the charts,” and it’ll be able to do it.

The other change I did: before, we had a market tab here. I merged that market tab into trade. Now the trade tab has the OHLCs with executors, the positions, and the config.

If you go here to “Depth,” you’ll also see the order book and the trades coming from this market. This is really nice because we shouldn’t need two pages for this. You can see the different markets being loaded and the data that’s available.

But I think this page is probably not so useful for you right now—the depth—because you’ll mostly be looking at the price and using the config to generate different configurations for the executors you’d like to deploy. But it’s nice to have.

There were some improvements on the UI for the different executors, but the biggest change on the trade page is merging markets and trade.

00:15:00 Bots Page

Fede: In bots, we also have some changes. Let me show you how a real bots page looks. These are the bots I’m running for one of the clients.

The bots page will show you: what is the realized P&L, unrealized P&L, total P&L, volume traded, the age that the bot is running. Now I also added here to see the controller config, and you have the logs of the bots. Here it’s failing because it doesn’t have budget. Maybe there’s an error here. You can see all logs and filter by error logs.

Mike: These are actively running bots right now?

Fede: Yeah, these bots are running from the—

Mike: Okay, nice. So basically each one’s a separate instance? Or is it one—

Fede: There are three bots because it seems like Dreamman deployed them badly—he should be deploying three bots in the same container, but for some reason he deployed three different bots. But in this case, it can be just one single bot sharing all three controllers.

We also have the editor here. We got the top three bots from the 15 bots we were running and said, “Let’s try to run this with more capital.”

00:16:30 Editor Page

Fede: Another change is we have this editor page. Instead of having controllers and configs separate, we have this editor page where you can see the code of the controller and update it if you want. You can also see the controller configs. We have all these configs that we were running.

You can analyze a config, update it, delete it, whatever. This editor helps you switch between controllers and configs and adapt the one you need. You can also upload a file—a YAML file or a Python file—if it’s a controller.

You can also create a new one from a template, so if you have the controller, you can pick it, all the parameters will be loaded, and you can create them.

Mike: To be clear, these are the same controllers that work in Hummingbot, right? If someone created a custom controller here without any changes, they could use it themselves as well?

Fede: Yeah. If they create a custom controller, they can just go to this UI and upload it.

Mike: Nice. I would say we’re focusing on controllers right now. In the future, we may try to support scripts, but right now we’re focused on controllers because each controller has this “total amount quote” that says how much in quote you want to give it, which allows us to calculate the P&L of your bots correctly.

In the future, we may allow people to run scripts if they want to continue using something from the past. But we recommend overall that if you’re using Hummingbot right now with controllers, this is a better way to run it than what you were probably doing before with CLI.

Fede: Yeah. If they have a script they were using, we could add a new tab that says “adapt script to controller”—we can spawn a Claude session that translates the script to a new controller.

Mike: Usually a script is using some custom gateway controller or something custom, so I’d say the use case for scripts is more someone doing something custom.

Fede: You can do the same in a controller if it’s custom—there’s no problem with that.

Mike: Yeah, anyway.

Fede: It’s just Python.

00:19:00 Agents Page

Fede: Then we have the executor stuff—same tab as before, you can see executors and all that. Then we have agents. I’m currently working on this, mainly unifying the sessions.

Before it was overview, strategy, learnings, sessions, and dry run. I removed strategy and learnings as separate tabs, and now I’m putting the strategy and learnings here. I’m trying to figure out how to improve the experience even more. Maybe I should add an editor like this one, maybe I should just let the user expand to check it.

I’m trying to figure out by testing what the best solution is. But I think you’re also not going to modify this directly too much—you’re probably going to modify these things with the agent itself.

I also made another change that’s not reflected yet because this was an older version of the learnings. I found that it was adding a lot of information that’s sometimes redundant. So I said it has to organize learnings into market data learnings and executor learnings, so it’ll probably keep the information more concise.

Mike: The question is, are these things users should edit or not? By having an editor, we’re saying these are things that could be edited by the user.

Fede: Could be. For example, let’s say I don’t like this insight—I can just go here and remove it, save it.

Or I’d like to add another learning to say, “Hey, please take a look at this because you’re missing when this happens.” You can manually input a learning from here, and it will be automatically incorporated. But you can either write it here or talk with the agent builder and say, “I would like to add this insight.”

Mike: I think for removal, what you just did of removing an insight is something people may want to do because it’s easier than trying to tell the agent. Overall, the two ways is actually not bad. The only thing I’d add is some type of expand or download button. Maybe just expand.

Fede: Yeah, they can access the file. Maybe an expand here would be nice. I’ll add it.

Then we have sessions here. You can see the trades that the agent took. This is one of the trades, this is another trade, so on top of the candles you can see where there was actually trade activity.

There’s one thing about the color—it’s not easy to spot where these trades are because it’s red and the same red. Maybe I’ll try to make it bigger or find a way to point out where these executors are.

Mike: Okay.

Fede: Overall, I improved the interface, putting this on the same level. Then we have the overview, take a snapshot—there’s a kind of overview for the executors.

And this view—if you go for each executor, you can see where they were and it will load the data around it.

00:23:00 Routines Demo

Fede: Lastly, we have the routines that you already know. These are the ways you can trigger a routine. For example, let’s say we trigger the “top movers.” This will give us the top movers on Binance Perpetual.

If I run top movers, I have this result, this output that’s probably what I’ll receive in Telegram. But here’s the change I made: what happens if this top movers routine can be run on a schedule—every minute or every five minutes? Where will I see this output? Because Telegram will be a little verbose, and sometimes I don’t want to receive everything in Telegram. That’s why I created reports.

If you go to reports, you’ll see that 34 seconds ago this one was created. This is what a report looks like. See, it generated this graph that shows the gainers and losers. You can expand the graph also. So it’s like—good.

This is nice because now we can create HTML with these reports, and it’s very simple to create. Let’s say we run the technical analysis on SALT—six hours of candle data.

Let’s run it. It’ll be here—as you can see, it’s running. When it ends, I see this output here. See, this is a picture—the same picture I receive in Telegram.

This is what I was trying to improve—this experience—because I have this picture but I cannot zoom in. I can see it, I can analyze it, but it’s not as good as HTML. Now if I go to reports, the HTML was also generated. Here I have the analysis and the HTML, so I can zoom in and understand what’s actually happening in the market.

This is a small improvement that the framework now has—including reports.

Mike: Can you walk through again how you tell a routine to trigger the report? Where are you defining that?

Fede: Actually, it’s very simple. You tell Condor to do it. But let’s say we look at the one we just created—top movers.

You see the run? First, I have this figure that I’m generating. What you need to do is import the report builder. At the end of the routine, you need this report builder source—this routine—to tell what routine is generating this report.

In the markdown, you add the markdown you want. If you want to add a Plotly chart, you add the figure you generated—the chart. If you want to add a table, you add a table. This step is what actually generates the report.

These reports you can find here in the charts folder. You’ll have the HTML generated by this report class. From here you can also clean them—removing the reports you generated.

I think this approach of HTML reports is quite convenient.

Mike: Are you gonna include some samples with this?

Fede: Yeah, I updated all the ones I have here—they’re also moved to reports.

Mike: Okay, got it.

Fede: In the project, I’m also providing this routine that’s loaded by the Condor agent. This has an explanation of how to add the report. I’ll provide the update on this too, so now your agent will know how to create reports.

Mike: Got it. Are you gonna show people how to do it now?

Fede: Yeah, I think the best way will be trying to create a report showing this. By the way, let me add this so I don’t forget.

So let’s see how we can create a report now. Any inspiration from the chat? Does anyone want to generate a report about something?

Mike: Do like a token or an indicator you want us to use, or even a strategy type maybe.

Fede: I don’t know what you want, guys. Just mention it in chat.

If not, we can move on.

Mike: Yeah. Actually, why don’t we do something on ORCA since that’s a token that has risen a lot recently. I think a couple of Solana tokens have gone up. Maybe we can look at ORCA and figure out if there’s—actually, maybe ORCA versus Meteora, that might be a possibility.

Fede: I like that.

Mike: Based on—

Fede: What I’d like to know is—yeah, maybe we can do analysis between ORCA, Meteora, and Radium, comparing also the market caps, maybe.

Mike: Yeah, I think it’s a good idea. If you want, we can also try looking at the revenue data from DeFi Llama.

Fede: That would be nice.

Mike: Do you have a link? Is there an API?

Fede: Data is free?

Mike: It should be, yeah. Why don’t you start the agent—start the building process. I’ll do some research into the DeFi Llama data while you’re doing it.

00:30:30 Live Coding: DEX Token Comparison

Fede: Okay. This is how I’ll start doing research. This is really nice because you don’t need to know—you just need to ask. That’s the best thing.

I’ll tell it—let’s create this as a routine. I’ll say: “Hi Condor, I would like to create a routine to compare the market cap evolution over time of ORCA, MET, and RAY. Can you check the GeckoTerminal API and see what data we have available?”

I’ll tell it to check the GeckoTerminal API. I created this GeckoTerminal Python wrapper a long time ago for getting data from GeckoTerminal. There are some examples in the code—in the usage, I created a notebook so you can see how to get networks, DEXes by network, trending pools, top pools, new pools, and also specific tokens on a network.

With this, I think Condor should be able to get the supply. With the OHLCs we should be able to see the market cap because I don’t think it’s showing market cap directly. Let’s see what Condor tells us.

It seems like it’s searching. I thought the GeckoTerminal API should also have market cap. Let me see.

Mike: Yeah, I think they have market cap and TVL if I’m not mistaken.

Fede: But I don’t know if they’re doing it for OHLCs—the output of the OHLC.

No, it’s just returning this, it’s not returning market cap, so what I have is correct. But I have the data of the number of tokens available, so it should be able to figure that out.

Mike: Okay. By the way, it looks like we can get fees from DeFi Llama. Let me send you the link. I’ll send it to you in Discord.

Fede: Okay. He gave me this change on file. I don’t know what this is. It’s the data of the—

Mike: That’s the GeckoTerminal data for these protocols.

Fede: Yeah. Okay.

Mike: So just to maybe more precisely define the type of strategy we’re talking about for the seven people watching and everyone watching YouTube afterwards: basically what we’re talking about is some type of portfolio allocation or stat arb strategy that’s looking at three tokens that are Solana decentralized exchanges.

All three—Meteora, ORCA, and Radium—are DEXes that Hummingbot has integrations to. We’re very familiar with how users might approach these. All three are AMM DEXes with AMM pools and concentrated liquidity pools. A lot of LP strategies you might want to use are probably using Meteora or Radium using concentrated liquidity pools.

Recently ORCA has shot up in the market. I think it went from $1 to $2—something like that. It spiked up to almost two, went down to one, recently spiked up to two again.

I think that actually puts ORCA’s market cap above Meteora and maybe even Radium.

Fede: I don’t think they beat Radium yet, but we’ll see.

Mike: Yeah.

Fede: One thing is—I just told this and see all the work it’s doing. It was actually able to say, “Okay, I can get the token and I can use GeckoTerminal to get—” and now it’s finding the top pools to get the OHLC data from them.

Mike: Cool. So the strategy—we’ll basically look at, try to look at these market caps or maybe even the fees these protocols are earning, because that’s also visible on-chain, to analyze which tokens are undervalued or overvalued given all these metrics.

It’s like a mix of using fundamental analysis to formulate a strategy to do some mean reversion perhaps or some other trading play. But overall, the first step, as Fede mentioned, is to identify the data you’re interested in.

Here we’re looking at market caps, the price obviously, historical revenues, and other factors. This is good for agents because in the past you’d have to put this in a spreadsheet and spend hours cleaning the data, putting it together, collecting it. Now you can hand all that off to your Condor agent.

Fede: I would say to avoid rate limits, use the data from Binance Perpetual and use the data from GeckoTerminal for the market cap calculation. Also, I’d like to include into the routine the fee revenue data. Here’s an explanation of how to get it.

Okay, let’s see. Oh sorry, it seems like it went to messages.

Mike: It should be okay. If it’s Claude behind the scenes, it should handle that pretty well.

But interestingly, as this is working, some folks on Discord have already reported trying out Condor with other open source models. Because actually—I’m not sure if you’re gonna show this later—but now you’ve added more support to the models menu, right? Beyond the defaults?

Fede: There’s more support for other models. David told me today that he finally integrated Open Router. Now with Open Router, first you can get cheaper requests, then you can get other models to use. There are also some free models you can use from the API there, and he told me they were able to do tool calls, so it’s actually nice to see.

Let me see what’s the state. With these two things I probably messed it up, but maybe this is working. I’ll need to create a new session. This might happen because remember it’s in trial, but—it was actually responding.

I’ll start a new session. Now it’ll analyze the routine we were creating for the market cap comparison and fee revenue.

Mike: Evaluate this later on, by the way, because I think your screen’s not coming in very clearly. I’m not sure if it’s just on my end or it’s on the actual stream itself.

Yeah, if in the audience you’re seeing blurry screens, please let us know because we’re experimenting with different ways to stream. Maybe we’ll end up using different software if you can’t see what we’re presenting.

Fede: Let’s make it continue from here. I don’t know if it’s—I’m seeing the screen on Restream well, but I don’t know why we’re still having that type of problem.

Mike: For me, my Restream is blurry, but I’m not sure if the actual output on YouTube is blurry as well. It’s hard to tell. We’ll see in the final output. I’ll try to clean it up.

Let me know if the quality is fluctuating. That’s one unfortunate thing about livestreaming. Maybe we’ll experiment with doing a pre-recorded one in the future.

Fede: Okay. Here it’s trying to update with the fees data, so we’ll see if it’s able to come up with the report. Now the final stage will be—run the routine and we should see the HTML report on the website.

That would be the goal: can we create in less than 15 minutes or 10 minutes a report that compares the market caps, the fee revenues of these three protocols, and just have a visualization?

We have five minutes left, so let’s see if we can make it.

Mike: Let’s see.

Fede: Can you run it? Let me see. It’s on Binance Spot—Meteora.

Mike: Yeah, Meteora is definitely on Binance Spot.

Fede: And ORCA is also—yeah. Okay. Can you run it?

Let’s see what we find.

Managed routines, this... Remember, the good thing about this is that it’s like code mode. I’m experimenting with code mode right now. I think I mentioned this the other day, but there are some people—mostly the guys from Cloudflare, some from Pydantic—pushing for this code mode thing.

Basically, instead of letting the agent use MCP tools directly, they have the tools, but they’re not calling the tools directly. Instead, they’re creating code with those tools, executing all that, and then just getting the output. That reduces token usage a lot.

Seems like the report was generated. Let me see what the final result is. If we go to Condor—okay, there’s something here from one minute ago.

Mike: Okay.

Fede: We don’t have the market cap evolution. Okay. I’ll tell it that the market cap evolution isn’t there. But we have the daily protocol fees.

Mike: Nice.

Fede: Actually, MET is outperforming all of them.

Mike: Yeah. That would be my intuition as well, because I think MET is actually making more fees than ORCA or Radium. That’s actually why I hold quite a bit more MET. But I do hold all three because all three are partners of ours.

But I’m a little bit overweight MET because I think the revenue is—I’m glad your chart is validating my intuition. Anytime you confirm your buys, it always feels good.

Fede: Yeah. I also have most of my portfolio in MET—probably mostly these values.

Mike: Nice.

Fede: I also told it the legends aren’t correct. But see, now in the state we’re in, you can just chat in Telegram and generate a report that compares the fees, that gives you a chart for market cap—it’s like—

Mike: And price as well, because you can also look at the candles and incorporate.

Fede: Yeah. I’m making it fix that issue.

Mike: Okay.

Fede: So in this chart, we should be able to see the market cap evolution. But the interesting thing here is that in FDV, ORCA is still lower than the other two.

Mike: That makes sense.

Fede: But check the fees in 30 days—

Mike: Yeah.

Fede: And this interesting “market cap over analyzed fees”—this is a nice proxy to see that Meteora’s value should probably be higher.

So yeah. I see the fix was switching from this—okay, let’s see. The new report is here, so now we can see it.

Mike: Does that update automatically or do you have to run it again?

Fede: No, he ran it again for me.

Mike: Okay.

Fede: What’s strange is that market cap evolution—this value doesn’t make sense to me compared to this value.

Mike: Yeah, the market cap evolution chart seems a bit off.

Fede: Indexed at... Ah, this is indexed to 100—this is the evolution, meaning the changes in market cap.

Mike: Yep.

Fede: I would tell it I’d like to see market cap as an absolute value.

Mike: Okay, got it. It’s probably using price as a proxy for market cap here. To get actual market cap, it either needs historical supply or historical market cap.

Fede: Yeah, but I have the FDV, so I have the total number of tokens. I can use price times that value. That’s what it’s doing, actually, for me.

But here the trade would be: short ORCA, long Meteora, based on all these things. If you want to have a kind of delta neutral strategy where you long one and short the other, I think it would be short ORCA and long MET based on the values we’re seeing here.

That might be a good idea. But what I want to show is: here’s how you can create these routines. Also, if I go back, it should be the new version. How fast we can iterate this is incredible—I’m already on a new version.

Mike: Nice.

Fede: This is crazy. These are real values.

Mike: Radium has always been higher than the other two despite the—

Fede: Yeah. But ORCA did come back because ORCA was lower than MET. Now ORCA is passing MET, so I think MET will come up.

Mike: Yeah.

Fede: But yeah.

Mike: We probably won’t cover this today, but let’s say you wanted to actually turn this into a trading agent. What would be the next step?

Fede: The next step would be talking with agent builder and saying, “I want to create a trading agent that uses this routine to analyze the data.”

Then I would be asked: when does it take trades, how does the strategy work, will it keep positions around the three pairs with changes? It would be a conversational flow with the agent builder. Then the agent will be able to run this routine on demand and create executors on demand.

That’s how it works.

Mike: So the agent would also run this routine which generates a report? So it’s kind of like you’d get the report that the agent is submitting?

Fede: Yeah. For example, if I go here and say—I have an agent called BB trader. Can you check the routine it has to calculate the indicators?

Yesterday I was creating an agent. This is one of the agents I’m currently trying to work on. This agent has a routine.

So the routine it has—it’s explaining to me here how the agent works and how it’s generating decisions. But I’d like to say: I want to focus on the routine. Can you add report generation to it so I can see the output in reports?

What happens here is: if I add the report, the training agent will be able to execute local routines and general routines. If the routine the agent is calling has the implementation of this report, when the routine finishes, I’ll find in reports the output of that specific routine.

So I can see what the agent was looking at when it was doing something. I’ll also probably add one at session level so I can keep track of which ones ran at that session.

Basically it’s doing the refactor right now. As you can see, the generate chart was returning the buffer of the PNG—because I was sending through Telegram that information. But now it’ll return a figure and have two paths: one that sends the PNG via Telegram and another that saves the data.

But the important thing is this is the data your agent will see. It’s good for you to understand what your agent will be seeing when trading.

Mike: Okay.

Fede: So it’s updating the routine. Let’s wait one more second so we can see the output. I think it’s getting really nice.

Mike: Yeah, it’s cool that because it has access to Hummingbot and also the internet, it can access pretty much any data source out there and help you visualize this.

Fede: Yeah. You can run this on a server, connect it to Condor, and have your Telegram wherever you are—you’re able to use this feature.

Mike: Yeah.

Fede: Yeah.

Mike: We should actually check how well the web dashboard works on mobile. We should make sure it’s usable on mobile, that you can navigate to these different tabs.

Fede: Yeah, that would be interesting. I’m always in favor of mobile usage, but I understand people want—

Yesterday I had a great experience just sending voice messages to Condor.

Condor can transcribe the messages and then send it to Claude. I recommend checking that too. At first it’ll take a little bit if your Condor session doesn’t have Whisper downloaded—it’ll download Whisper and then be able to do the transcription.

Mike: Can you demo that? Are you saying users would have to—the LLM will download Whisper or do they have to do it themselves?

Fede: That would be an automatic process. But the first time it’s doing the process, it will be downloading, so it’ll take a little bit of time.

See here—it ran the routine. You see this routine, and also it generated this report. This is a report the agent is receiving. This is to analyze the candles. If we want to analyze the candles, this is a report generated by that specific routine.

00:54:00 Voice Trading Demo

Fede: Let me demo what it would look like to send a voice message to Condor. I want to—

Mike: Do something like “how’s it going” or “how’s it feeling today.”

Fede: Hey Condor, how is it going? So you see that here appears “audio transcribing voice,” and here it transcribed, and now it’s sent to Condor again.

Mike: Nice.

Fede: “All good, ready to trade. What do you need?” I’ll tell it: can you tell me the price of ORCA USDT on Binance Perpetual? Let’s see if it’s able to get it.

Transcribe voice... Get market data. ORCA $1.96, perfect.

Now I’ll tell it: I would like to create a grid executor on ORCA to go long between the prices of 1.9 up to 2.02, and I would like to invest $300 with a take profit of 0.15%. Let’s see if it’s able to do it.

Mike: Okay. Let’s see.

Fede: It’s getting the executor schema.

Let me go ahead and create it. I’ll tell it... yes, create it.

Mike: So just hitting the talk button and holding it down, talking, and then releasing it—is that how you’re doing it?

Fede: No, I’m with the phone.

Mike: Voice message, right? Yeah. Sorry, I’m a Gen X American, so I never use voice messages. I’m asking as a complete voice message noob.

But honestly, that’s a really good experience, especially if you’re on the go trying to place a trade. I’m gonna start trying that.

Fede: We are already doing some trades.

Mike: Nice. You already put a grid on. Okay. So you basically put a long grid between 1.9 and 2.02. Where’s it trading now? ORCA 1.996? Okay, 1.94.

Fede: Yeah.

So yeah, we finally created some—

Mike: Yeah. So basically this long grid—you’ll be buying ORCA between a little bit below the current price up to 2.02. If it hits 2.02, the grid will stop, right? And then you’ll—

Fede: Yeah, I’ll take profit at that value.

Mike: And then if it hits 1.89, that’s a stop loss and you’re gonna get out as well.

Fede: Yeah, stop loss. But “keep position” is set to true—yeah, I’ll be holding the long position. But I don’t think that’ll be a good idea for ORCA right now because it’s very volatile. But yeah, this is a great—

Mike: I think there’s a good chance it’s gonna hit 2.02. Yeah. But maybe we’ll let everyone know what actually happened to this grid.

Fede: Also, I really like the experience of just talking, because for me it’s like—I much rather prefer to talk rather than write.

Now I can say, “Can you tell me the state of that grid?” and it will just tell me. If not, I’d need to write that, and I’d probably be two times slower writing it.

Mike: Yeah. I see what you mean, especially for individual trading. The Telegram voice interface is actually really amazing.

Fede: Yeah. “Your grid is cooking.”

Mike: Nice.

Fede: But overall, this is what it is. I think we have room to improve, but always—week after week it’s getting better.

Mike: Yeah. To try it out, the link is condor.hummingbot.org.

Like I said, we’re trying to improve it week after week. It’s open source, it’s free, and it’s maintained by Hummingbot Foundation, which is the same folks behind the Hummingbot open source framework that’s been widely used by professional market makers since 2019.

We’re also working with exchanges in our day job to integrate into Hummingbot, and some of those will likely be sponsors in the hackathon.

As one final note, as I mentioned, the hackathon is now open for registration. I think the link is in the very top of the chat on YouTube. We’ll also make sure it’s in the episode description when we share it.

You can already start registering for the hackathon. You can fill out your profile and then find collaborators among other participants. We’ll actually kick off the hackathon in about three weeks.

00:59:30 Wrap-up

Mike: Maybe next time, we’ll actually get into more of the agent structure. Now that we’re able to create agents, I think the next step is to really try some agents out and see how we can edit them and iterate on them as they run.

But I think routines are a really important part of this because the first thing you want to do is formulate what your strategy is. You may have a hypothesis like we did right now about MET versus ORCA versus Radium, but actually analyzing and figuring out how you want your agent to behave given the data you have is the next part.

Maybe we’ll actually continue this next week and try to figure out: is there some type of trading strategy we can employ? If so, how should we do it? Should we use grids or should we use the LP executor that we now have in Hummingbot that will be supported in Condor too?

There’s a few ways we can approach it. But overall, we’d love for you guys to just try it out, register for the hackathon, and see what kind of agents you can build. Hopefully we’ll find some cool agents, give them some real money, and see how they actually perform in a 48-hour trading competition. That will end the first trading agents—or Condor agents—hackathon. That’s what we’re calling it now.

Fede: Yeah. All right.

Mike: Okay.

Fede: I think that’s all. I’ll see you next week.

Mike: Yep. See you guys. Bye everyone.

Fede: Bye.

The episode also includes a candid discussion about this week’s DeFi hacks (Drift, KelpDAO) and how to keep your DeFi assets safe. Sometimes the best trade is no trade.

Watch the full episode: YouTube

Get started with Condor: Condor

Episode Highlights

17:00 Backtesting Philosophy

Fede doesn’t hold back on this one:

“You will never be able to have a backtest that works exactly as real life.”

Why? A few reasons. First, there’s queue priority—you never know where your order sits relative to everyone else’s. Second, there’s path dependency: if just one fill happens differently in real trading versus your backtest, everything after that diverges completely. And exchanges don’t tell you who placed orders when, so you’re always guessing.

24:00 PMM Mister Deep Dive

Mike and Fede walk through the PMM Mister strategy parameters, and there are a lot of them. The key insight is how they all work together.

Mike works through the math live to make sure he understands:

“So if I’m placing 1% buy orders and max executors is 20, the most I’ll ever have on the book is 20%?”

Fede confirms: “Good student!”

35:00 Running the Backtest

The actual demo is quick—half a day of backtesting runs in about 34 seconds. But there’s a crucial detail: you need one-second candles for market making strategies. Fede explains that he often gets 30+ fills in a single minute, so one-minute candles would completely miss that activity.

54:00 2% vs 10% Portfolio Allocation

To show why backtesting matters, Fede changes just one parameter: portfolio allocation from 2% to 10%. The difference is dramatic.

With 10% allocation, position builds way faster—the bot hits $300 in inventory almost immediately instead of gradually. But then something interesting happens: trading stops completely. The bot hit its max position while underwater, and because profit protection is on, it won’t sell at a loss. So it just... waits.

“If the market never recovers from this point,” Fede says, “this bot will be stopped forever.”

76:00 Trading Bots vs Trading Agents

A viewer asks about AI latency, which leads to an important clarification. In Condor, trading bots and trading agents are different things.

Bots are deterministic—pure code, no LLM involved. They run on one-second ticks or faster, and backtesting works perfectly for them. Agents, on the other hand, use LLMs to make decisions. They’re slower by design, running every minute or so.

“When you’re doing HFT, you probably don’t want the LLM involved in every single tick. That’ll slow things down.”

Full Transcript

Intro & Market Discussion

Mike: Welcome everyone to another episode of The Bot Pod, a weekly podcast where Fede and I demo the latest features in the Hummingbot open source framework. We are the maintainers of Hummingbot, and our goal is really just to democratize the world of algo trading and market making by providing free technology that’s available to anyone in the world.

I’m coming at you from Sunnyvale, California, and Fede is in Mar del Plata, Argentina. Feel free to leave your questions in the comments and we’ll try to surface the best ones.

Today’s a special episode because we’re excited to present backtesting in the new framework that we have. We just launched this new agentic harness called Condor that allows you to use AI in your crypto trading.

Backtesting is an area that we’ve always wanted to support. Having Hummingbot integrate directly to the exchanges, you can fetch data from exchanges, use it for backtesting, and have a good understanding of what it’s like to run your strategy before you actually deploy live. However, because there’s a lot of complexity with backtesting—you have to have a framework that’s fast, that can do a good job of simulating reality, but you also have to fit it into the type of strategy that you want to simulate—for that reason it’s taken us a long time to actually create a backtesting framework that’s really usable and flexible enough where people can use it for all of those strategies.

But I think we’re pretty close to having that, and I’m excited for Fede to show off what he’s built. But before we get into it, it’s been a rough week in crypto markets. I think there’s been a couple hacks recently with Drift and with KelpDAO. Fede, how are you feeling about what’s going on in crypto markets this week?

Fede: Yeah, hacks usually happen every few months, so it is very sad that it happens, but it is part of the game. Personally, I usually do mostly LP, so it’s more difficult to hack. I also do some lending—that’s probably the most risky part. But I think that is not good because you want to have trust on the protocol. I can give you some yield, but...

Mike: Yeah, the lending thing’s hard because I think a lot of people just aren’t really aware of all the different risks that exist in all these protocols and in the underlying assets. Because I think in this case, it wasn’t really Aave’s issue—it was like this staking token that people could lend into Aave and borrow other assets.

Because this staking token was hacked due to some bridge hack—this is KelpDAO—the people in Aave were stuck with bad debt, basically. So I would say yeah, the good thing is none of our assets or the foundation assets were hit. But I should tell you, I did actually move all of the foundation positions back into the wallet. So now we’re just holding USDC in wallet.

Fede: Doing nothing instead of earning interest on the lending protocol.

Mike: Yeah, doing nothing instead of earning interest. I think that specifically, I usually never like those risk-taking coins because I think those mechanisms... you can get, by the way, you stake ETH, but then you go to rsETH and then you can lend that for ETH again into Aave and do the cycle again. So it’s obvious that those types of mechanisms—at the end, someone has to pay.

In this case, I feel bad for the folks who were just lending USDC or USDT, but they weren’t aware that because of the way these Aave pools work—there’s like 20 assets in the pool, so anyone can lend or borrow any asset—I think rsETH was one of the assets of the pool that could be lent, but it’s probably not really the one that most people are borrowing or lending, which is USDC or USDT. But what happens in these pools is you basically bear the risk of the worst asset that’s in the pool.

Fede: Yeah.

Mike: That’s why actually I pulled our money away from lending protocols because I was looking at the list and I’m like, I don’t even know what some of these tokens are. I don’t want to be exposed to some random USDX stablecoin out there.

In the old days when the yields were higher—when I first got into DeFi, the lending protocol yields were like 10% or 15% per year.

Fede: In Anchor. Anchor was—

Mike: Oh yeah, Anchor had 20% back then.

Fede: At that moment I was lending most of my USD there, and when the market went to $0.96, I withdrew and sold everything.

Mike: Really? Okay, that’s good.

Fede: Yeah, because it was at that price for a little bit of time and I was like, okay, this is a stablecoin and people are getting afraid of this. If one gets afraid and starts selling, there’ll be an escape event. So I just said, okay, I will take the loss and I will go out.

Mike: Yeah, that’s also why I pulled our money out—because other people are pulling money out, you don’t know if that can cascade into something else in the future. So better safe than sorry. Happy to earn 0% yield right now for the time being.

Anyway, let’s get into it. I see some questions from the audience about backtesting. I think a lot of people are interested in backtesting.

What is Backtesting?

Mike: Maybe why don’t I just give a brief overview of what backtesting is, why it’s important, and how we enable that in Hummingbot.

You guys probably know that Hummingbot integrates to many exchanges, and one of the main reasons people use Hummingbot is to standardize trade execution across lots of exchanges. For example, you can run an HFT market making strategy on Binance or OKX or HyperLiquid. But many people probably didn’t know that you can also use Hummingbot to fetch real-time and historical data from the same exchanges using the same exchange connectors.

Starting a few years ago, we incorporated the concept of candles where you can now fetch historical data from the exchange. And now you can also use Hummingbot to take the data and apply a backtesting algorithm—basically a simulation against that historical data—so that you can know how your strategy works.

It takes some configuration in the framework because ideally you want to run the same code that you’ve developed for your strategy using the backtest and using it for testing against production data. So you want to use historical data, but you also want to be able to take that same code without any modification and run it on live data as well.

That’s why there’s been many different options. We have tried to build a user interface for it, but you can also do this using the command line, using the API directly, which gives you the full power of all the different configuration parameters.

So that’s just a preface to give you a brief overview of how backtesting works. Basically, we are using the exchange integration directly to fetch historical data from the exchange, have an engine that will calculate performance of a strategy given that historical timeframe, and then a UI to help you visualize and understand that backtesting performance.

What Fede will show today is basically the full end-to-end process of taking an HFT market making strategy, backtesting it, but then also deploying it live and comparing the live results to the backtesting results.

Fede: Yeah. One thing that I would like to add—you got me thinking with the lending stuff—I think that the first one that demonstrates their mechanism is not safe for someone to deploy, because if they pull, there are tokens that are unsafe. I think there should be one lending protocol that comes up with a more institutional or solid process. And that will probably take time—hopefully Kamino gets better.

Mike: There have been attempts at this over the years. There are other protocols like Morpho that I think is more customized and more institutional. But I would say it’s not so much that Aave isn’t safe—it’s more just like the structure of these lending protocols are such that as a borrower, you have to pick and choose your pools very carefully because you’re exposed to every single asset in the pool.

Funny enough, this should be my area of expertise because when I was working in finance 20 years ago, I was creating credit derivatives like CDOs, and these CDOs work the exact same way. Basically you’re exposed to the entire portfolio of risks, and so the worst risk in the portfolio is the one you’re exposed to. But I’m glad I’m not doing that anymore because there’s a lot of risk there. I’m glad I’m doing HFT now with you because HFT is honestly more fun. When you’re making money, when you’re losing money, you’re not as exposed to these kinds of black swan events that might happen.

Spot-Perpetual Arbitrage Analysis

Fede: Yeah, actually a funny thing about HFT—I was doing some research. Can I share my screen now?

Mike: Yeah, go ahead.

Fede: I was doing some analysis and I think that there might be an interesting strategy that we can create between spot and perps. This, for example, is the token CUT. So what I did was—first of all, I was looking at this token here and it was like, okay, it went up a lot. That’s why it has a lot of volatility. But if you check the one-second candles, for example, in this one second, each candle is one second. So this is the movement of one second—it’s like moving 0.14% per second. It’s quite huge, the movement that it has.

But it also carries a lot of risk because you’re holding this... I don’t know what they do actually. “Delivering deep liquidity and native yield.” But this Katana is not the one for Polygon.

Mike: No, I’ve never heard of this network before.

Fede: I don’t know if Polygon got divided into Katana. I don’t remember. But then it’s also like this perpetual, right? And this also moving 0.16% per second. So I was wondering, okay, is there an arbitrage that can be produced here?

So I spot my pair—and here I can see the perpetual and the spot. We can see that mostly the perpetual price will be lower than the spot one because if not, you can just short perps and buy spot, right?

If it’s the other way around, it’s simpler to make money because you can just short. But the thing here is what type of strategy can we come up with that can do market making in one while hedging exposure? What I did is—the spread is very high. So if the price stays in a certain horizon of time and you can hedge the exposure of the price while you’re doing market making...

I’m thinking more like a strategy where you can say, okay, I will allocate in spot a maximum of, let’s say, one thousand dollars, and in perps I will hedge up to $600. So you can start doing market making and hedging a portion of the assets that you are acquiring. But some of the assets that you’re going to acquire are going to be reversed. So all that yield should compensate the difference between the spot and the perps, plus the funding rate.

This was like very last night. I couldn’t almost sleep thinking how I can improve this graph to incorporate the funding rate plus this thing. But it is nice to see—for example, you can be quoting selling here and buying here or the opposite to reduce the spread.

Mike: So in this chart, is it the top line that’s the spot?

Fede: The spot is this one—the top one, the one that is higher.

Mike: Okay.

Fede: Actually I should also add a legend here. The thing is sometimes they are together. But having a legend would be good. Usually spot has less volume than perps.

Mike: Yep.

Fede: But the thing is that they’re moving very together. So this is like probably a real HFT thing that we can do.

Mike: Yeah, there’s probably some strategy you can do. If the spot is higher by a certain amount and funding rate is positive—because you want to probably go long spot and short perp. Usually, yeah.

Fede: But that’s a scenario where spot is higher. In this case, like short pays long. So you’re rewarded by going long. The thing is that you can’t really short in spots—that’s the problem. You need to have certain assets.

Mike: Yeah. You probably have to have it be something like PMM where you want to acquire some position, and that position allows you to short.

Fede: Yeah. When you go down. But yeah, there probably is something here.

Condor Update Command

Fede: But that’s one thing. The other thing that I want to show about Condor—first of all, if you’re not updating for a long time, just update via git pull. But if not, I added a new command that is update. And if you run the update right now, it’ll say you are up to date with the main branch. But if there is a new change on the main branch of Condor, you can just use this command update and you will update your whole Condor system.

So that’s really cool because right now you don’t need to worry about terminating the terminal, all that stuff. You can just run /update in Condor.

Mike: Yeah, that’s good. We’re making changes to Condor pretty much every few days, so it’ll be useful for you guys who are using Condor just to run the update command to help you update to the latest version.

Backtesting Philosophy

Fede: Now I want to talk a little bit about backtesting.

Mike: Okay, go ahead.

Fede: So for backtesting, I’m very skeptical about people that say, “Oh no, this backtest is the best backtester that you can have and it will be perfect.” That’s all bullshit for me because you will never be able to have a backtesting that in real life works exactly as the backtest. You will never be able to match the same behavior unless you’re more like a taker strategy. You will never be able to simulate that.

Why? Because first of all, the order book is FIFO—First In, First Out. So if I put an order and you put an order behind me, my order has priority. There is a kind of priority here. It’s impossible to know. Let’s say that you put $100 in five orders, then I put two orders, and then another guy puts three orders, and then the book was removed $50. You never know if the $50 that were removed are behind me or before me. It’s impossible to really know where you are in the queue because the exchange will never tell you the order or who is the participant doing this change.

So that’s the first thing that is impossible to replicate the real world—the queue position.

And secondly, let me show you one market that we trade—this one, USDT/BRL, for example. See that in the first level, we have $600K and $28K of orders here. Doing a backtesting here—it’s like no sense because how can I, and see what is the volume that is actually being traded? If you run a backtest here, this will never be true because there will be a lot of people before you and your order gets filled.

So that’s the first point that I want to transmit about backtesting. It’s impossible to simulate a backtesting that is like the real thing. That’s why I’m very pro of using the backtesting as a proxy. How? The backtesting should help you understand the sensitivity that each of your configuration parameters has.

Let me give an example. I have this parameter that tells me how much portfolio allocation I will put around the mid price from the portfolio that the bot has. Okay, I want to understand what happens if I move it to 10%, to 5%, to 2%, and that will explain me how my bot will behave if I move this parameter.

So for me, with backtesting, you’re not trying to say, “Okay, this is perfect.” You’re just trying to say, “Okay, what would happen if I use this parameter? What would happen if I use this other parameter?” And the flow is more like: use the backtesting as a research tool, then deploy a bot with that, and understand what is the difference between what you backtested and what is the actual result.

Mike: Okay, got it. So let me just paraphrase what I think I heard you say: don’t treat backtesting as a prediction for exactly what will happen when you deploy it live. Instead, because these strategies typically have 10 or 20 different things you can change—different parameters—you should use backtesting to gauge the sensitivity of one parameter versus another. It’s assessing it on a relative basis instead of on an absolute basis.

Fede: Exactly. It is more like on a relative basis and also to discover how your strategy works, how it behaves, all that stuff. And also making sure that your strategy is doing what you’re expecting. That’s the other thing.

And another thing—for example, backtesting market making strategies is, for me, impossible to have a real simulation. Let’s say that your strategy puts orders around mid price, right? And when one order gets filled, usually you have a few options. You can have a time that will block the replacement, you have a distance that will block the replacement. You can have different mechanisms to block a replacement.

But actually, the market maker will always place orders around the mid price with a different shift or with a different spread based on volatility. But the shift will be based on the inventory that you have, or the shift will be based on the prediction you have for the market, and the spread can be modified by the volatility.

So basically you’re going to place two orders, and based on the fill, you will say, okay, this order will be able to be replaced when this condition is met. Perfect. If the real bot and the backtesting at some point have one fill that is different—one order fill that is different between the backtesting and the real—the following path is completely random because one will wait and the other one will continue replacing.

So at that point, the coincidence is broken. The backtesting to simulate reality is as fragile as one order mismatch. Because after there is another fill, the path is completely different.

Mike: Path dependency is what you’re trying to say.

Fede: Path dependency here. So that’s why what I mentioned—thinking about having the same result of a backtesting in a real bot is absurd. My recommendation is treat it 100% as parameter research.

Mike: Yeah, I think Raj also agrees. He said in a comment, “Yeah, he likes backtesting to see how the model will behave, how it skews mid price, how wide is the spreads.” But yeah, he doesn’t trust backtest P&L. Raj, I think that’s actually also the approach we recommend as well. So it’s good to see that you’re already taking that approach.

Backtesting Engine Demo

Fede: So well, now let me show you what the backtest looks like. For that, I will start in Hummingbot. The good thing is that yesterday I backtested 11 days. But the good thing is that the way the backtesting works is that we use the same controller code that you run in production. So the backtesting actually loops and executes the method that the controller has to take the decisions.

And the abstraction that we have is that the controllers of these strategies create executors. So these executors are like standardized execute actions in exchange. So it’s very easy for us to simulate that specific executor’s behavior. So that brings us like extensibility in terms of how we can test or backtest different types of strategies. We can backtest directional strategies, we can backtest market making strategies.

And the addition of this last month was the usage of the position hold. Because before we didn’t have position hold. Now we have, and in order to backtest it, we had to update the backtesting engine for that.

Let me revert because I was doing this... let me use the one that is in main. I added a script here that is backtest_pmm_mister. It is just a CLI. And basically...

Mike: Yeah, I should mention, these backend improvements were done in the latest release, 2.14. So that was just released a couple days ago, on Tuesday. And if you look at the scripts folder in 2.14, you’ll see these three demo backtesting scripts in the scripts folder. And so this will help you get a feel for how to backtest using the API.

Fede: This is using Hummingbot.

Mike: Oh, sorry. Yeah, using Hummingbot. And then it’s also improved the backtesting endpoints of the API, so that now we can also use it in Condor. So overall, 2.14 actually adds a lot of key backtesting improvements, which is why we’re discussing it today.

PMM Mister Strategy Parameters

Fede: Yeah. To not enter into too much details about the strategy because it’s complex—this PMM strategy has a lot of parameters. Basically we have this method that we can build a config. That is called at first. And then we have initializing the backtesting engine, run the backtesting with a trade cost—while here it’s hardcoded, it should be using the trade cost. We are not passing the trade cost, but while it’s hardcoded here, you can change it or you can add it here.

And then we have this backtesting result that gets the backtesting figure. Then it writes in an HTML figure—this is a Plotly figure—and then we are going to render it in the browser.

Mike: Yeah, I was just noticing how short that file is. Does that mean the backtesting engine is kind of generic across all strategies and doesn’t really need to know much about how this particular strategy is designed?

Fede: Exactly. It’s completely generic because remember that the only output of a controller is an execute action. So you can just abstract that for all the different strategies that you want to backtest.

Mike: Got it.

Fede: So, here this is a dictionary that we’re using. As you can see, we’re using PMM Mister. The controller type is generic. The connector name is the connector that we pick. The trade pair, the total amount quotes. Then the leverage. This portfolio_allocation is basically how much—let’s say that we have here $1,000. The 2% would be, okay, you can put the 2% of the $1,000 around the mid price at a time.

Mike: Okay.

Fede: So this will put $20 around the mid price.

Then we have what is the target portfolio—50% in base asset. So it will try to acquire a target of 50%. The min_base_percentage is how minimum I will keep the level of the base asset in inventory. So as it’s 30%, and this starts with zero position, it will try to acquire the base asset at minimum 30%.

What that means is that it will not sell—it will not place sell executors until it reaches 30% of position. So at the beginning, it will be like an onloading phase where the executor is going to be buying, buying.

Mike: Are you assuming that you’re starting with zero base? You’re starting with quote?

Fede: Yeah. It is assuming starting with zero. You can also put initial balances here, but I recommend assuming it starts with zero.

Mike: And just to clarify—so the portfolio allocation is 0.02, so does that mean you’ll be setting 2% of your overall total amount quotes in orders?

Fede: Yeah, around the mid price.

Mike: Is that typical? Because 2% seems pretty low as a percentage. Is that typical?

Fede: Yeah. But see this value that is max_active_executors_by_level. This means, let’s say that I have—let’s keep it simple—I have two levels. Only one sell and one buy. This will have 2% around mid price. Let’s say that the buy level gets filled. It will place a take profit, right? But if the price continues going down, it will be waiting until it hits the take profit up to this activization_time—you told me this word does not exist in English, but I will need to change it—but it will wait 1,660 seconds until it considers that part of the inventory.

Why? Because we are giving it the chance to hit the take profit. So if it didn’t hit the take profit, it will wait up to 1,660 seconds. But we want to still place more orders. We don’t want to wait all the time because if not, the bot will be stuck.

So this max_active_executors_by_level tells you that you’ll have at maximum 20 times the first level to replace.

Mike: Okay.

Fede: So it will place the 2% again, 2% again, 2% again, in another buy executor. But what happens here is—in order to place another executor for the same level, it has to pass the cooldown_time that is 30 seconds.

So we need to wait 30 seconds to replace another one. And also it will need to pass the price_distance_tolerance. That is, I will not be able to place another one if there is a minimum distance of 0.02% or 0.002%.

Mike: Okay.

Fede: So with this and this, we are able to restrict the amount of replacements that will happen while I am trading with a reactive level. This gives you a lot of flexibility in terms of how aggressive you want to be.

Mike: Okay, got it. Let me put in some numbers so I make sure I understand how this works. So is it like, let’s say you start with a thousand dollars and you have 0.02 portfolio allocation. So it means that you’re basically putting like 1% above the mid price per side, right?

Fede: Per side, yeah.

Mike: So let’s say basically it’s like a $10 buy order, a $10 sell order.

Fede: At first, no. At first, no. Because if it’s zero inventory, it will not be able to place sell.

Mike: Okay, fair enough.

Fede: It will try to only place buy orders because it is trying to get up to the minimum base percentage.

Mike: And then, the way this works is that because the max executors, max active executors by level is like how many times can I replace my buy order, for example. If it gets filled, I place another buy order. I don’t want to do that forever. So I can do that a maximum of 20 times, assuming the market’s continuing going down. Is that right?

Fede: Perfect what you said.

Mike: Okay, gotcha. That means if I’m placing a 1% buy order, the max I’ll ever have on the book is 20%, on the buy side.

Fede: Yeah. Go student.

Mike: Okay, okay. Nowadays—don’t worry, I’m going to pass all this into AI afterwards and have it write down a real transcript because yeah, it’s... but I know what you mean. I actually understand now why backtesting is so important because you have all these different interlocking kind of parameters that work together.

So it gives you a lot of flexibility into how to design your market making strategy, how much inventory risk you want to take, how quickly you move up to your inventory percentage, how much deviance you have. But all these things can be changeable. So how do you know what the right configuration is?

Fede: Yeah. That’s a really important thing that I think we should be doing. For me, this is a place where you do, okay, let’s try this parameter in 5, 10, or let’s say 5, 15, and 30. Let’s try having a grid search with very big values to understand what is the P&L, what is the volume generated, what is the number of position holds, all that stuff.

Do some analysis and then I will continue doing search. My goal would be to see if we can do an auto research with Claude.

Mike: Right?

Fede: If we can summarize how is the output of the backtesting into something that Claude can understand and he can be searching parameters. That would be cool.

Mike: That should be doable actually. I think all you really need for auto research is some type of definable objective and things you can change. And we have that already. And I think there’s also—I would bet it changes a lot depending on the token that you’re trading.

Fede: That changes a lot.

Mike: Yeah. So there’s many different variables here that you can play with.

Running the Backtest

Fede: Yeah, that’s true. But now what I want to show is what it looks like in backtesting, and I want to show what happens if I do a change on one parameter so we can visualize what is the position hold or how the position hold is actually working, right?

So let’s say that we keep this one like 2% portfolio allocation. The way to run it is backtest pmm_mister <number of days>. Let’s put just like 0.5 days.

It’s important for doing backtesting on PMM Mister, for example, or a PMM controller—it doesn’t make sense at all to do it in one-minute candles. Because personally, when I run market making bots, I have multiple fills in the same minute—like sometimes more than 30 fills.

Mike: Yeah.

Fede: So if not, the backtesting will only be able to take one fill in that minute. So one-second candles is crucial.

The only exchange that we support here that provides candles in one second is Binance Spot. So you probably need to buy a server in a region where Binance is allowed because the data is public, and you can either run the backtesting on the server or you can use the Hummingbot API.

But another thing that you can do is to use Tailscale. That lets you connect up to 100 devices for free in your private network. So what you can do with Tailscale is you can use it—let’s say you have a server in Tokyo—you can use it to forward your request through Tokyo. So that’s when it comes useful.

Mike: Okay. Can you just explain quickly why do you think it doesn’t make sense to do backtesting if you have one-minute candles?

Fede: Yeah, because that will depend a lot on the type of strategy. If you are doing, for example, a directional strategy that is taker—yeah, it would be okay to do it in one-minute candles. It’s just to evaluate the signal if the resolution is in that order. But if it is a market making strategy where you have multiple fills in the same minute, the backtesting will not be able to see in the same candle where it goes up and down.

So it’s impossible to know how many fills you have. The only way that you have to evaluate if there were multiple fills is if you are using the one-second candles, because you have each candle to evaluate that move.

Also, this engine is also—I would say it is also possible to backtest directly with trades, which I think will be the next step if you want to go deeper—to backtest directly with trades. For now, I will just recommend one-second candles because there is—here’s the point of flexibility—lower than one-second resolution for me would be considered overfitting. You would not be able to get a higher result or a better result in a lower resolution than that.

That for me is not enough. Comparing one second with trades would be mostly not enough. And I can tell you this by looking at the market. Let’s say for example that we go here to BTC/USDT, let’s see in one second—this is probably the biggest market on Binance. Let’s see. No, today was USDC/USDT, but the second biggest market that has 1 billion of trading volume is BTC/USDT.

And this is the one-second candles, guys. So this movement in the second was 0.001%. So the last minute the move was 0.07%. So going to a lower value than this is—I don’t think that makes sense. I think that would be more considered like overfitting. And the effect that I mentioned about the order book priority just breaks everything. So for me, as I mentioned, use it as a proxy, not as ground truth.

Understanding the Backtest Results

Fede: So well, let’s run backtesting with this. It says the time that took to process half a day was 34 seconds. I want to do some benchmarks—like what happens if I increase the time to, let’s say, one day, two days. Maybe there is an exponential decrease and maybe it will be better to partition and chunk the backtesting. That’s more to understand the behavior. But overall it is quite good. 34 seconds, 35 seconds for the candles—that is the result that we have.

And here it also created this chart. Let me see if I can zoom in. That’s not good. It also created these charts that is the Plotly chart that it generates.

There are three panes. The first pane shows the candles and the executors that it created. The second pane shows the P&L and the volume traded. The volume is this one from here that has this axis here. And also has different P&Ls. We have the executors realized P&L, the position realized P&L, the position unrealized, and obviously the difference of those two and the total P&L.

So the yellow line is the total P&L. The purple is position P&L. See that the P&L... and here the last pane is the position. See that as soon as we are adding more position, the P&L that is the purple one starts moving a lot.

Here, for example, we could take some actions to, okay, let’s reduce the position because we get some profits. So those are the things that you can probably improve. But see that we accumulated almost $300 in position. We generated... the interesting thing is to say, okay, the difference between the yellow line and the purple line—

Mike: The yellow line is—so the purple line is the unrealized?

Fede: The yellow is total P&L, and the purple is the position unrealized P&L. So the difference between the two of them is the position realized plus the executor’s P&L. Here you can see how much this distance—if the executors are taking profit, it will be increasing.

Mike: Got it. Okay. Got it. Because the executors are basically what you’ve already realized and the position is unrealized if you’re accumulating it.

Fede: Yeah.

Mike: And then I also see a position realized P&L.

Fede: Yeah. That’s when you are selling and moving that sell executor to position hold—so you’re actually reducing the position. See for example, here, see in this case that we have $370 in position, here we have $340, so basically $30 were reduced from the position.

Mike: Got it.

Fede: There is a parameter that I added that is called profit protection. That will only let you create sell executors if your position hold is positive. So for holding a position on the sell side, you can only be in profit. That’s a good one to protect the P&L.

Mike: Okay. And this Plotly chart—when you ran the script, this appeared in a browser, right?

Fede: Yeah.

Understanding Position Hold

Mike: And now let me show you these—it is interesting that this is where we can see the actual backtesting mechanics. See that here, for example, these that are white are executors that we placed and were refreshed by the early stop.

Fede: Basically the orders we placed that were not filled. Is that correct?

Mike: Yeah. Orders that we placed that were not filled.

Fede: So see that it placed the order here. The market never reached out to this point. So it never considered it filled.

The ones that are green are the ones that we placed and at some point the take profit was hit.

The ones that are blue—usually this happens in a downtrend—are the ones that we filled, but the market went down, so I never recovered to hit the take profit. So we started accumulating position. So this moves to the position hold.

See that at this point we are—here we are saying, okay, this will go to the position hold. And here the position hold moves from 69 to 79. We said that we are going to put 2% of the inventory, so that’s normal—that’s $10.

Mike: Yeah, I see.

Fede: And I think we had a minimum base percentage at 0.3, so it’s trying to get up to $300 of position.

Mike: That’s another interesting thing because as you see here, there are never sell orders like these white things. Let’s say that we are analyzing these white that are not refreshed. All these white orders are below the price.

Fede: You see this, right?

Mike: What that means is that we are not placing sell orders. Why? And the answer is that we are still below the 30%.

But let’s see a place where we are above. So here we started being above... let’s cut from here to here.

Fede: See that here—up to this point, we were not placing sell orders. And here we turned to above 300. So here we should be starting to place orders. Let’s see if that happens. Let’s zoom into this part.

See that here we have the first white thing. It should be—it should start here, actually. So let’s see if there is something here. These are greens—green executors or green lines that go from up to down. It’s because those are sells that are taking profit.

So here we have the first—and here. Okay, here we also have—let me see more here. Let’s say it should—we should see it starting here. Okay, perfect. It’s perfect. See this? Here we have 298 position. And here we move to 300. See that when we moved to 300, we have the first sell executor, which is this one.

Mike: So it’s... and here we have the first sell that was not filled. So that is how the position is actually accumulated.

Q&A: Take Profit vs Hanging Orders

Mike: Let’s try to answer a question from the comments while we’re doing this. Raj asks, “Why do you use take profit and stop loss for market making strategies?” So what he does is he matches the buys and sells to try to figure out the spread.

Fede: Yeah, actually the approach that I think he’s taking is similar to the hanging orders approach that was in the original Hummingbot.

Mike: Yeah.

Fede: No, actually it is the same thing as well. It’s not the same thing that you are doing—it’s very similar to what you’re doing. I am not using stop loss. I’m only using take profit.

And you can think—imagine that you’re placing two orders to capture the spread. If one order gets filled and you are going to leave the other order in the market—right, so that’s your approach.

My approach is: I have these two orders, and if this one gets filled, I can place the take profit here or I can place the take profit above. So my approach is more flexible because once my order is filled, I can decide what is the spread that I want to capture.

Like almost—no, at no time do you get—let’s say you put a spread of 0.02%—almost never will the two orders be executed at the same time. And the thing is that once one gets executed, then at certain seconds the other one is executed.

So my approach is: instead of taking the other pair of the order—the take profit of this one or to make the spread—I have a configurable spread that I want to capture that might be lower than that spread or might be higher, depending on the situation that I am.

Plus if you think about it, let’s say that you want to build inventory, but you also want to take profit from the spread. You can also only put buy orders, and when they are filled, then you can create a take profit to be the other layer. But if you put the two of them and you wanted to buy and your sell order was filled, then you’re in a worse scenario than where you started.

So with this scenario, you can enforce, okay, I will enforce the buy order first before the sell order, because I want to build inventory. So with this approach, you can also position from one side to the other. Those are the reasons why I like this approach more—of placing the orders.

Mike: Yeah. The way I would try to explain this is I think we made an improvement to this overall market making strategy when we went from the V1 strategies to the V2 strategies. And one thing that gives you is you can handle take profit and stop loss at the individual order level.

So you can replace an order level, configure exactly how you want to take profit and stop loss on that filled order. But you can also control things at the portfolio level. This is when it’s like you’re only placing 1% of your order in orders, how often do you replace that level? How often do you build inventory overall?

So there’s an individual order level in terms of how you handle fills, and then there’s a portfolio level in terms of how do you handle your overall inventory you’re building and reducing. So if you think about it at these two levels, I think the new approach gives you more flexibility now to handle different things.

And I think actually that’s why backtesting is important—because how you handle orders at an individual level does affect as well how you treat things at the portfolio level. So being able to tune parameters that affect both—for example, some of the parameters in PMM Mister are affecting individual orders and how you handle them. Other ones are affecting how much inventory you want to build, how often you cool down before you replace executor levels, those kinds of things. So again, you can just try lots of different things and see what the effect is from a backtesting approach.

Flexibility of Position Management

Fede: Yeah, and also I would like to add—let’s say let’s follow this example. Let’s say that here we build inventory that we want to have between 30% to 40% of the inventory. So let’s say that here we reach up to 300 and 70—no, it is... let’s say that we want to have between 300 and 200.

So here we are allowed to place buy and sell orders, but then we ended up having $300 of inventory. Now my bot should not acquire more inventory, right?

Mike: Okay.

Fede: So in that case, but I don’t want to stop the execution and I have positive P&L on the bot. So in that case, I can still place sell executors that when they get filled, I place a buy order.

So if the market goes down again, I am just making profits. But if it’s going up, I’m selling and helping the position—so I’m reducing the overall position and taking profit of the position generally. So this approach gives you flexibility of, okay, I want to generate yield from the mark outs, plus I can manage the position by holding at the end.

Comparing Portfolio Allocation Settings

Mike: Can you maybe run the backtest again, but maybe we change like min base percentage at 10%? Maybe just so it’s 10% to 30%—you can see.

Fede: No, I would like to put portfolio allocation into 10%. But before that, let me show you another thing that is important here that I didn’t mention. But see that there is a shadow here that shows how many active executors at a time.

So you see that we put 20 and we are never using 20. We are using a maximum seven executors at a time. So this is another thing that you can see—if this parameter is actually used or not. This was max active executors by level. We put 20 and it was never filled.

Let me show you what happens if I put, for the same strategy, 10% of portfolio allocation. Keep this in mind.

Mike: Okay.

Fede: For the comment—yeah, for the unmatched orders, the take profit is like the other leg. Imagine that instead of placing the two orders and being random which one you fill first, you can place the order that you want of the two of them, or you can place the two of them, but each can have a specific take profit that you can configure at the level that you want.

At the same time, you can also—there is another strategy, another market making one that just has orders. So you can do without take profit, just with order executors. But yeah, see this example.

What we have here—I put the portfolio allocation at 10%. So when there is position hold, see, position on hold is increasing much more faster than before. Before, around here we got up to 30%... let me see if I can put them side to side.

Mike: And the difference is now you’re placing 10% of your total inventory in orders. So it’s 5% on each side per level. Is that...

Fede: Yeah, exactly.

Mike: See that? This one was the first one. We build inventory progressively. And this one is the new one—see that we are building inventory very fast. We are at $300 here already.

Mike: All right. What happens here? Can you tell me, Mike, what happens in this part?

Fede: We are not trading.

Mike: Yeah, you’re not trading because—so I think I know why actually. So I think it’s because before you were buying because you were still within the minimum base percentage and max base percentage. At that point there, you hit the max base percentage, so you’re not—

Fede: Yeah, the 0.7.

Mike: Yeah. But you’re also not selling, I think, because you have that profit protection.

Fede: True.

Mike: So you don’t want to sell what you accumulated for lower than you bought it for.

Fede: Exactly. That’s exactly the reason why it stopped trading here. Because as we exposed a lot of money, the market went down. So if the market never recovers from this point, this bot will be stopped forever.

So here you can understand how the portfolio allocation will affect the trading activity—the continuity of your trading activity. See that here, it stopped trading because the unrealized of the position is negative and we have the cap of the position. So it’s not able to start selling.

See that here—what happens is that once the position becomes profitable—that here. Okay, I need to use this one. Sorry. See that here the position becomes profitable.

See here it’s negative. Here it’s profitable. So here when it’s profitable, see that it starts placing sell executors again.

And the ones that are purple are the executors that ended up in position hold. So you see that here we start having a lot of these purple ones. They are reducing the position now. So they’re using the position that we created.

Mike: It’s selling those at a profit then, because...

Fede: It’s selling the profits. See that here it says position realized P&L $1.80. So it actually made a profit from the position itself. And the position that we still hold has $2 profit, $3 profit.

Mike: Okay. Nice. Nice.

Fede: Here we are selling more and see that now the position realized is $3.40. But unfortunately here we are buying a lot again. You see, all these blues are going to cost very much money.

Mike: Yeah.

Fede: But yeah, here you can see how—and this is normal for a market maker, right? When the market goes down, you accumulate position. When the market goes up, you free up that position.

So well here, there is a lot of party—see, this movement is a complete party.

Executor Abstraction and Generic Backtesting

Mike: Yeah. And I think actually this kind of illustrates some of the reasons why I think users should want to use this more advanced version of the PMM strategy instead of the V1 version. Because the V1 version just places orders. And so it doesn’t really factor in the breakeven price or the cost of how much you incurred to accumulate that inventory.

Whereas here, because you’re tracking the position, you can basically say, okay, you know what the breakeven price was. And so you can have a parameter that says, don’t sell at a loss. And you can prevent—I think one of the biggest risks of the original strategies was you are always buying high and selling low and not taking into account the breakeven price of your positions.

Fede: Yeah, that’s exactly what the profit protection does. And if you think about it, it’s very similar to Grid because if the market goes down, you’re going to accumulate exposure. But it will only sell in profits. That’s similar.

Mike: Yeah.

Mike: Actually, I have one question. I was thinking this earlier. I think other people in the audience may have the same question. You mentioned earlier that this works because we’re using this concept of an executor to standardize what happens when you trade. Does this backtesting work on every strategy or every executor, or are there limitations?

Fede: There are limitations. You can only backtest the strategies that are using position executor, DCA executor, or grid executor. The rest of the executors are not covered. Some for obvious reasons—like the arbitrage executor and the cross-exchange market making executor will never be backtestable with this framework because for that you need order book data. So it’s not possible.

Mike: Okay, yeah. In the future, we probably will add the order executor.

Fede: Yeah.

Mike: But maybe within that executor mix, so let’s say I have a strategy that uses order executors—does that, like, can it be any strategy, like a generic controller can also now do backtesting?

Fede: Yeah.

Mike: Or do I have to use a certain framework? Oh, wow. Okay. Great. Okay, that’s a change from before, right?

Fede: Yeah, that’s a change from before. There is still some knowledge that has to be added to the design of the controller because the update process data—we only run once at the beginning. This is to optimize the metrics calculation.

Now I will show you, like for example, the Bollinger one. Let me see Bollinger—that is to optimize the parameter calculation. And then the method that we’ll run time over time will be the method of determine_execute_actions.

So you have to keep in mind that the logic of the indicators or the data that you are going to use should be in the update_process_data. And the method will be executed only once. And all the logic that computes, okay, my executor is this, my data is this—all that stuff, that should be in the determine_execute_actions. Like calculations probably—I need to add an explanation better of that.

But see that here, I’ve backtested a Bollinger controller. Unfortunately it lost money—that was $6. But it’s just a random Bollinger trade. See there?

Mike: Can you share the Plotly for that as well?

Fede: Sorry, I’m showing it but on the other screen. See that this controller does not have position hold because the Bollinger—the directional trading—these versions didn’t include position hold. But probably we can add a version of directional trading with position hold.

Condor UI for Backtesting

Fede: And this is the other visualization that you can run inside Hummingbot. I’m trying to move this, but right now I feel more confident with Plotly for the charts. But there is already an implementation of this in Condor.

And see that here, this is a new thing—the bot trade interface. Let’s say that now I put USDT/USDT. The trading interface now shows the latest executors that you deployed and the position hold. If you have position hold, that is nice because it takes the real position that you are holding. You can also change the timeframes here, all that stuff.

We also have this bots page that has the controllers where you can see the controller code if you want, and you can also create a new config for this controller. Here’s the PMM Mister—the one that we’ve been talking about is here.

Then we also have the configs that we have loaded. So see that here I have this config. I can copy and clone into a new one if you want to create a variation of it. Like this.

The archives is not yet there. I’ll work on it probably next week to visualize the previous bot executions, but I still need to improve it. Here we have all the executors, but I need to improve the visualization.

And here we have the backtest—also here. As you can see, this is a backtesting of Bollinger V1. Here you can see the config that was backtested. Here you can see the actual candles.

Mike: Is this backtesting the same backtesting that we just did in Hummingbot?

Fede: Yeah. The engine is the same. The chart is not, but I’m trying to improve it to have a very similar experience.

Mike: Yeah, I have a tip actually. So you may want to check out a library called Apex Charts. Because you’re using JavaScript for Condor, right?

Fede: Yeah.

Mike: So yeah, because when I created the reporting dashboard last night for using the old Datadog data, I just asked Claude to find a lightweight chart library that allows you to zoom and pan. And so it recommended Apex Charts.

Fede: Okay, I would check it out.

Mike: For that one.

Fede: I would check it out. But for now, I have this. And for—I think that if there is one like PMM Mister—because sometimes it takes a little bit too long to load. I need to improve loading a lot of stuff.

This is PMM Mister. See, it is much more buggy.

Mike: Yeah, I can check out the front end actually. It is probably something—it probably has to do with some type of Ajax JavaScript thing that you’re doing. Because I think you’re trying to load it dynamically each tab, right? When you click on it.

Fede: No. Yeah, yeah. That’s because the number of data that comes is a lot because you’re receiving a lot of executors, so you cannot load everything in memory. Imagine that you have 100 backtestings run—it will explode directly. So you need to do it dynamically. But as it’s a lot of data, see that it is slow.

But this backtest is for—

Mike: Yep.

Fede: But it’s almost the same data that I show in Plotly. That here we have. But this backtest, as I mentioned, is in one minute. That’s what I think is—it’s not true. They are not. I will not be confident on this. But yeah.

Mike: Yeah, basically.

Multi-Server Deployment

Mike: Let me answer a couple questions from the audience while we’re doing this. So just, I would say, in summary—this is a new interface in Condor, this backtest page. But yeah, I recommend if you’re interested in checking out—try out this backtesting interface, but also as we showed earlier, try the backtest scripts directly that are using Hummingbot because that way you can get a low-level understanding of how the backtesting works.

In addition to just running it in the UI, Tiger Trade asks, “Can I run executors on different locations like Binance Tokyo?” And yeah. Fede, do you want to take this one?

Fede: Yeah. In that case you will need to have a Hummingbot API server in Tokyo, and you will need to have a Hummingbot API server in Singapore, and each API can run executors. So that would be the way that you can do it.

But from a single—but from a bot running from a bot, it will not be possible because a bot just runs on one machine.

Mike: Yeah. Also, I think it’s important—the concept of executors is a software-level abstraction. So it’s basically the way to standardize the trading activity that happens on spot and perpetual exchanges. So you can basically apply an order executor on different types of exchanges and have it deliver the same result back to you.

That’s why we can backtest using candles, because we’re taking advantage of this abstraction. However, these executors are being run by a certain server, right? The server is the Hummingbot API that you’re deploying on AWS Tokyo or in AWS Singapore to run it.

So that’s why I would say the way that I recommend starting off is just load Condor locally. So you have an understanding of having API running locally, have Condor running locally. And then once you’re comfortable with that, then you can deploy the API on a server and still connect. You can still use your Condor locally, for example, to control that server that’s running in Tokyo.

Co-location and Latency

Mike: Another question—let’s see. Yeah, so Tiger as a follow-up asks, “Is it possible to run an abstraction in the bot and send RPC commands to Bybit for execution?”

I think that’s actually what’s happening. Maybe I’m not understanding what your question is, but I think that’s actually what’s happening because the API is talking directly to Bybit or Binance. That’s why people run Hummingbot because it’s an open source framework that integrates directly to the exchange with no intermediary in the middle.

So when you run an executor, you’re basically telling the server to connect to the Binance API via WebSocket and place orders and cancel orders and do everything directly with the exchange.

So you’re anchored to that machine because Binance is going to track rate limits from a certain IP address. So you know that one server is going to be communicating with Binance and you may have two different bots on two different servers that are both talking to Binance consuming rate limits separately.

So there is some kind of—there is always, you’re always anchored to one machine from a Binance perspective, because you’re sending direct instructions to that server. But there’s nothing that prevents you from using one version of Condor and controlling five different servers, each of which are running different bots.

Fede: Yeah.

Mike: But yeah, but I would say if you need co-location, you need to run the servers in Singapore, Tokyo—

Fede: That’s the definition. Yeah. You’ll need to deploy a Hummingbot API on each of these servers and then run the bots that you want, basically.

Mike: Yeah. But actually that is exactly what market makers are doing. What we know of market makers that are running Hummingbot co-located on servers close to the exchange or even in some cases on the exchange infrastructure itself. And that’s why we designed Hummingbot API—it’s basically a piece of software that you deploy on a server. And so you should always run it as close to the exchange as possible.

AI Model Latency Discussion

Mike: Okay, all right. So yeah. And one follow-up—the decision-making latency. I think what he is referring to is some type of speed measurement—how fast Hummingbot is actually communicating with the exchange. I think that’s what they’re referring to.

So yeah, I would say—

Fede: That, I think for that is everything is possible. You need to just use the framework that we have to implement it. We have a layer of MQTT that will be able to communicate the different bots. So off the shelf you will not have that feature, so you need to build it.

But what you can have is one Hummingbot instance in Singapore, one Hummingbot instance in Tokyo, and all of them can be communicating the messages through MQTT. So each one can be measuring the latency. You can have a central report and then have another one that distributes the orders. But you need to build it. You need to build that connection. It’s part of your development.

Mike: That’s right. And actually, I’ll try to find an article because remember Victoria, one of our community members, did use Hummingbot to analyze speed between AWS Tokyo and Singapore. She did a lot of measurements in terms of how fast Hummingbot is. And so yeah, I’ll try to post that in a comment.

As Fede is showing the rest of the backtesting in terms of what that looks like—but overall, I would say, I think she found Hummingbot API is pretty fast. But there are some interesting differences between, let’s say, Osaka and Tokyo or Singapore in terms of where you deploy the server.

Fede: Yeah. Yeah.

Mike: The last thing that I want to show is this routine page new that we have that basically—we will be able here to run the routines from this page. As you can see, I just ran this one. I will write again, but basically I’m trading for a guy—a Brazilian guy that trades on these markets.

So I just said, okay, I want to know if there is—because right now we have zero fees on BTC, so I just wanted to know, okay, what is the market of BTC regarding comparing USDT and BRL. So it’s 1% of the market.

And the other thing that I wanted to know is if I quote the BRL in USD, what is the actual price discrepancy? If there are crosses—is there natural arbitrage opportunities to rebalance my BTC and BRL. And also counting that I have negative fees.

So well, this is the power of the routines—simple entities that you can receive data. That’s cool.

Mike: Yeah.

Fede: And also we have the top movers. These are private, so you are not going to see this, but as you can see, I can get the text, I can get the table. And with that, I think that is all for today.

Mike: Okay.

Distinguishing Trading Bots vs Trading Agents

Mike: Yeah, I do want to cover one more question from Tiger. I think this is actually an important point to bring out. Yeah, they ask regarding decision-making latency—he is really referring to the AI model latency, how long it takes to get information to the agent or to the LLM, get it back, and how routines and tools speed this up.

So I think this is something that I think we should cover maybe next week or the following week. Because one thing to clarify is there’s two different things you can do with Condor. You can do trading—you can run trading bots, and you can run trading agents.

Currently the way we’ve designed it, only the agents are injecting the LLM in the middle and using it to make decisions or anything else. When you’re doing trading and you’re doing trading bots, you’re actually just doing things the traditional way—you’re creating more like HFT deterministic algorithms and everything. So backtesting, everything else—that stuff is not using the LLM in the middle.

And it’s designed on purpose actually, because our view is that when you’re doing HFT, you probably don’t want the LLM involved in every single tick. That’ll slow things down. Instead, you probably want the agent at a higher level, like deciding which bots to start or stop and all that kind of stuff.

So that’s why for now, the backtesting—we encourage you to just do things the old-fashioned way. Create it, backtest it, run it in Condor. And that is not using the LLM.

However, once you build a routine and then you go to the agents tab and you build an agent, that’s when you’ll be using the LLM to help you make decisions. And you’ll notice that’s actually why it’s slower—every tick might take 60 seconds, because you want to give the LLM time to process and make a decision.

But when you’re doing HFT, your tick is probably one second or lower because you’re constantly sending orders to the exchange.

Fede: Yeah. Perfect. I think that was a really good session today.

Mike: Yeah, it was.

Fede: The agent can oversee—the agent can oversee the bot and modify, but it will not be in real time. You are going to execute the tick of the agent every X amount of time.

Mike: Right.

Fede: Probably in the future we are going to create some real-time agents. But for now, the current agent that we are offering is more like ones that you can execute every minute or X amount of minutes. So that will probably be the current state.

We’re going to go step by step for the real-time agents. We probably want to code probably with open source models. Maybe we can release a Hummingbot model or Condor model on Hugging Face.

Mike: Yeah. Yeah.

Fede: Fine-tuning models.

Mike: I’m currently watching a series on Hugging Face. The other day they were showing the new thing that will come is the RL for Agents.

Fede: Oh, wow.

Mike: Instead of doing DPO or RLHF—I don’t know the exact name—but it’s like how you do fine-tuning with LoRA, QLoRA, all that stuff. It is fine-tuning the agent. It’s not fine-tuning the model—it’s fine-tuning the agent.

So I think that there’s a lot of power there. I will be probably playing around with that. But I think that for our case, it’s perfect. That is probably what we want to do for our case.

Fede: Yeah, I agree actually. And I think for us, we’re just going to keep on building. Every week we’ll just come out here and demo the new things that we’ve launched every week. So I think that as we continue doing this, in a few months, I do think we’re going to have some pretty intelligent agents that are doing auto research and backtesting and forward testing at the same time. And at that point it’s going to get pretty crazy.

Mike: Yeah.

Wrap-up

Fede: Alright everybody, thanks again for joining. I’ll put on some more closing music. Do you know how many people we have today?

Mike: 18 people watching right now on Discord—or on YouTube. So yeah, I think we’re starting to get a bit more participation every week in the live streams. But yeah, I’m hoping that we can get up to even more once the hackathon kicks off and we’re doing workshops and showing people what—

Fede: Yeah.

Mike: So yeah, anyway, we’ll see you guys next week. Same time, same place. And yeah, we’ll try to get this posted on our Substack in the next few hours.

Fede: Yeah.

Mike: Alright guys.

Fede: Okay.

Mike: See you later. And we will talk to you later.

Fede: I like that music. Okay, bye. Bye.

Dear Hummingbot community,

When we launched Hummingbot in 2019, we gave individual traders access to the same market making strategies and exchange streaming connectivity that Wall Street quant trading firms use. But as traders scaled up — more exchanges, more bots, more capital — they hit a ceiling imposed by Hummingbot’s original command-line based interface. Monitoring multiple trading strategies, adjusting parameters on the fly, responding to market conditions: these tasks don’t scale easily, which is why most trading firms employ significant operations and engineering teams.

Today, we’re excited to formally launch Condor, the next-generation Hummingbot user interface that removes that ceiling. Similar in design to OpenClaw, Condor is an open source agent harness that helps you create AI agents that automate trading tasks. Condor connects your chosen LLM to the Hummingbot trading infrastructure, letting you use natural language to execute trades, run trading bots, and deploy autonomous trading agents across 50+ exchanges and blockchains. Now, a single person can run a large-scale trading operation!

Read the announcement post to learn more about why we built Condor and how it works.

Next month, we will launch our first Condor Agents Hackathon with $15,000+ in sponsored prizes to showcase agentic strategies built in Condor.

We can’t wait to see what you build.

Michael Feng
Co-founder, Hummingbot

📺 The Bot Pod

Check out our new weekly podcast in which Hummingbot CTO Federico and I explore the intersection of AI and crypto trading. In the first few episodes, we demonstrate how to use Condor.

This weekly podcast replaces our Hummingbot livestreams and monthly community calls. In addition to demonstrating new capabilities in Condor, we will provide community updates after each release and invite guests from the Hummingbot community.

Subscribe on YouTube or find weekly episode highlights and transcripts at hummingbot.substack.com.

🚀 What’s in the Hummingbot v2.14 Release

This release adds support for four new perpetual exchanges:

• Architect Exchange

• Decibel

• Evedex

• GRVT

Now, Hummingbot users have more venues where they can run algorithmic trading strategies, exploit funding rate differences, capture arbitrage opportunities, and earn platform incentives!

The release also includes:

• Gateway DEX Connector Refactor — Refactored Gateway connectors to use network (i.e. solana-mainnet-beta) as the connector identifier instead of DEX name.

• Backtesting Improvements — Grid executor simulation, position holds, and Plotly visualization

• Rate Oracle Refactor — Oracle-centric fee and PnL calculations for perpetuals

• Binance Update — Updates the Binance Futures perpetuals connector to use the new WebSocket endpoint format, ensuring compatibility with Binance's upcoming migration

• XRPL Improvements — Support for all markeBBRL and EUROP markets, order precision fixes

  v2.14 Release Notes

Security Notice

Beware of scammers impersonating the Hummingbot Foundation:

• We NEVER DM you first

• We NEVER sell or airdrop HBOT tokens

• HBOT is only earned through completing bounties

• Report suspicious activity in our Discord #scam-reports channel

We’re back with Episode 3 of The Bot Pod! This week, Mike and Fede introduce one of Condor’s most powerful features: routines. These lightweight Python files let you automate tasks, fetch external data, and run scheduled reports—all without burning tokens on LLM reasoning.

Also, we’re excited to announce that Botcamp Cohort 13 starts next week! Use the discount code INFOSESH from the episode for 25% off. After the cohort, we’ll host our first Condor Agents Hackathon with prizes from crypto funds and exchanges. Sign up at botcamp.xyz.

Watch the full episode: YouTube

Episode Highlights

6:00 What Are Routines?

Fede breaks down the three key concepts in Condor’s architecture:

• MCP Tools: Standardized way to present tools for agents

• Skills: Markdown folders with instructions that load into context when needed

• Routines: Lightweight Python files that execute deterministically without loading into memory

The key insight: routines are simple, reliable, and don’t waste tokens. They’re just Python code with a config class and an async run() method.

11:00 Types of Routines

Two types of routines exist in Condor:

• One-shot: Execute once or on a schedule (every 30 seconds, hourly, daily)

• Continuous: Run forever with a while loop until manually stopped

14:00 New Condor Features Demo

Before diving into routines, Fede shows off recent improvements:

• Self-update feature: Update Condor directly from the interface

• New trade page: Deploy any executor type from the web UI

  • Order executor (simple buy/sell)

  • Position executor (with take profit/stop loss)

  • Grid executor

  • DCA executor

27:00 Hello World Routine

The simplest routine demonstration:

• Configure parameters in the config class

• Run it once, run it in background, or schedule it

• Output appears directly in Telegram

32:00 Top Movers Routine

A practical routine that scans Binance for volatile markets:

• Fetches ticker data directly from exchange API

• Returns top gainers, losers, and high-volume movers

• Written entirely by Condor—zero manual coding required

35:00 Technical Analysis Routine

A more sophisticated routine that:

• Fetches candles via Hummingbot API

• Calculates trend, volatility, support/resistance

• Sends charts as images to Telegram

• Suggests grid parameters based on analysis

40:00 Live: Building a News Sentiment Routine

Mike and Fede build a CoinTelegraph scraper live on stream:

1. Tell Condor: “Create a routine to parse news from CoinTelegraph”

2. Condor writes the Beautiful Soup scraping code

3. Debug and fix dependency issues in real-time

4. Run the routine to fetch 15 latest crypto news articles

47:00 News-Driven Trading Demo

The complete workflow from news to trade:

1. Run the news routine to fetch articles

2. Ask Condor to identify tradeable tokens from the news

3. Condor identifies NEO based on treasury restructuring news

4. Run technical analysis routine on NEO

5. Deploy a long grid based on the analysis

53:00 Preview: Routines Inside Agents

Next week’s episode will cover:

• Global routines: Available to all agents

• Agent-level routines: Scoped to specific trading agents

• How agents can call routines every tick for data processing

Next Week: Routines Inside Agents

Now that you know how to create and run routines standalone, Episode 4 will show how to put them to work inside your trading agents. We’ll cover the difference between global routines (available to all agents) and agent-level routines (scoped to specific trading strategies), and demonstrate how an agent can call routines every tick to process market data without burning tokens.

Join us live next Friday at 9am PT / 12pm ET on YouTube, Twitch, or X. Drop your questions in the live chat—we answer them on stream.

Full Transcript

Intro & Market Discussion

Mike: Welcome everyone to the third episode of the Bot Pod. I’m Mike, this is Fede. We’re the maintainers of the open source Hummingbot framework. Every week we come on here and demo what’s possible with Hummingbot and our new agentic harness, Condor.

This week we’re going to go over something called routines—a component you can build in Condor to help automate tasks either for yourself or your agent. I’m really excited about today because routines are critical to making your agents more token efficient and more reliable. You can also use them for yourself to get daily reports, scan for arbitrage opportunities, things like that.

But before we get started, let’s talk about what’s going on in the markets. We’re traders at heart, and we know lots of you are too. It seems like the market bounced a little bit this week, Fede?

Fede: Yeah, it seems like we’re getting back a little bit. It was a long time coming. Some tokens are at the lowest price of the last two years. But I’m very bullish overall about the ecosystem. This past year is the first time I’ve seen common people talking about crypto without being afraid.

Here’s an example: I live in Argentina, and you can’t buy an iPhone directly here—there’s no Apple store. The resellers told me they’re now doing settlements via crypto because before they had to go in a car with cash. They’re also using crypto for cross-border payments to Miami. When those kinds of people are adopting the technology, that’s real adoption.

Mike: Yeah, crypto as a technology for cross-border payments—that’s the core use case. Everyone wants to save money. No one wants to pay 3% to a credit card processor or 5% when changing money at the airport. The purpose of crypto is to make those transfers almost free using crypto rails.

Before we dive in, there’s a QR code in the upper right corner that goes to the Hummingbot newsletter where we publish weekly episodes with notes and transcripts. We also publish monthly posts for new releases of Hummingbot and Condor.

The other thing Fede and I do is run Botcamp, an education platform that teaches people how to build algo trading strategies. The next cohort starts next week—there’s a 25% discount code in the description. After this cohort, we’ll be running an agents hackathon where people can build agents with Condor and win prizes from crypto funds and exchanges.

Understanding Routines

Mike: Alright, let’s get into routines. Fede, what do you want to start with?

Fede: I want to talk about the concept of what a routine is. Right now there’s a lot of content about AI—skills, MCP tools, all these different things. We introduced this concept of routines that works in Condor.

Mike: Actually, Claude just introduced routines the other day too, and they’re conceptually similar. I’m not sure they copied us—probably not—but we did start it first.

Fede: Okay, so let’s break this down. There’s MCP, which is a standardized way to present tools for agents. It has prompts, resources, and tools, but really only tools are used.

Then Claude came up with skills. A skill is basically a folder in your file system that contains a markdown file explaining the skill, plus scripts for how to do something. It’s a package that lets your agent perform certain actions repeatedly. When you tell the agent “I want to do this,” if it detects that a skill applies, it loads that skill into the system prompt. The benefit is you don’t load everything at once—just what you need.

Now, routines are different. Instead of exposing a markdown file with lots of context that guides the agent, a routine is just a Python file with a configuration. It has a config class and an async run method. The difference is: routines are very lightweight and simple. You never load anything into memory. You just execute it and get the response.

Skills are like a recipe with a folder, description, and instructions. Routines are deterministic code that runs reliably every time.

Mike: So to clarify: a routine is a Python file that does something you want done, and because it’s code, it acts deterministically and reliably every time. A skill is more like teaching an agent a general capability—the agent has to interpret instructions and then do something. They serve different purposes.

Fede: Exactly. The routine is lightweight. If you want to do something specific, just use this routine.

Mike: When would you want to use routines?

Fede: It’s very open—you can do whatever you want since it’s just a Python file. In Condor, you’d typically use the Hummingbot API. We have a skill that contains instructions on how to create routines, so Condor knows the patterns. You can create anything you want, but within the scope of Hummingbot is where you get the most value.

Today we’re going to try something crazy—we’ll see if we can parse a news website like CoinTelegraph, process the data, and have the agent run technical analysis on tokens mentioned in the news.

New Condor Features Demo

Mike: Before we get into routines, can you show off some of the new features you’ve been building into Condor? Every week we try to make improvements to Hummingbot and Condor, and this week Fede has made some big improvements to the interface.

Fede: Sure. First, I’m working on a self-update feature. When there’s a new update of Condor, you’ll be able to compare your branch with the main branch and update directly from the interface.

We’ve also improved the Hummingbot API in terms of executor reliability. Here’s the web dashboard with portfolio evolution over time and a layered view of different assets.

I added this new trade page where you can create any executor:

• Order Executor: Simple buy or sell—could be a market order or limit order

• Position Executor: One order with take profit, stop loss, trailing stop, and time limit attached. This is based on the Triple Barrier Method used in machine learning for finance, invented by Marco López de Prado

• Grid Executor: A more advanced version—you place a set of orders in a grid, each with take profit

• DCA Executor: Helps you dollar-cost average into a position

Mike: What’s important about all these executors is that they all start and finish, and they report their ending values—amount purchased or sold, P&L, and any positions left over—back to the agent. This means if you’re running an agent with the ability to execute different types, it gets the same information structure every time. This allows your agent to trade on multiple market types while having the same view at the top level.

The reason we added this trade menu is to teach users exactly what your agent will be doing once you program it. Place individual executors, see how they operate, understand the information structure.

Fede: Here’s a cool thing about the DCA executor. You can see how the breakeven price changes based on your levels. If I set level one at $100 and level two at $200, you can see the breakeven price moving closer to the second level as the amount increases. This visualization helps you understand the impact of your configuration.

Q&A: Long-Term Memory in Condor

Mike: We have a question from the audience: “How does Condor scale long-term memory via RAG versus session journals?”

Fede: We’re actively testing this. I’m working on reducing system prompt context by about 15%. What enters memory is the agent prompt and learnings shared across all sessions. We’re very restricted about what to keep.

Then we have journals and snapshots. Snapshots are one per session for each tick the agent runs—these aren’t included entirely in the system prompt. Only the journal and learnings grow. We’re not doing RAG on the journal—RAG is only from snapshots when the agent needs it.

For journals, we need to evaluate whether to compress the data. Maybe we don’t need all of it available. We’re also testing with Gemma 26 billion to see if we can include open source models and avoid paying for expensive LLM providers.

Mike: With trading, a lot of data is numerical, so storing text isn’t always useful unless it’s actual insights learned. We’re trying to have snapshots contain structured data of each tick, and agents only write down insights or observations they can use later—instead of processing raw text every time.

As we add open source models and discover what works, we’ll keep refining the framework. This is actually a good segue into routines, because one role of routines is to reduce the tokens the LLM spends figuring something out—it writes a Python program that processes data instead.

Fede: One interesting idea: a Botcamp student showed me a framework called Mem0 for memory search. They have this concept of “K language”—compressed English without filler words. Like “candle red trade” instead of full sentences. For trading journals, we might develop an internal compressed language to reduce context size.

Hello World Routine

Mike: Alright, enough intro. Let’s get into routines. Show us the simplest possible routine.

Fede: This is the Hello World routine. If you clone the GitHub repository at github.com/hummingbot/condor, you’ll see a routines folder with sample routines.

We have two types of routines:

• One-shot: Execute once, or schedule to execute at a frequency

• Continuous: Have a while loop and run forever until you stop them

The Hello World routine is a simple one-shot. All routines have a config class where you define arguments, and a main async function that’s the entry point. In this case, it just says “Hello.”

Let’s run it in Condor. Go to routines, you’ll see the list of routines in that folder. Here’s Hello World—run it, and there’s the result.

You can also run it in the background and the output gets sent to chat. Or schedule it—say, every 30 seconds. See? Run number one. In 30 seconds, we’ll see run number two. Once you create your routine, you can schedule it however you want and receive information in Telegram very quickly.

To stop it, go to routines, see the running ones, and hit stop.

Top Movers Routine

Mike: Can you show something more practical, like the Top Movers routine?

Fede: This one isn’t in the codebase yet, but I created it to show top movers on Binance. It pings the API directly and gives me a report: top gainers, top losers, top movers on perpetuals.

Mike: Can you show the code?

Fede: This code was written by the agent. It’s simple: a config where you set the top N, whether to include volume, losers, and whether to send to Telegram. The run method creates a session, processes the data, and that’s it.

Mike: This is a good example because this top movers data isn’t in our API. Every exchange has many different data APIs we can’t all incorporate into Hummingbot. But if you want to access this data and have your agent use it, the best approach is to write a routine that incorporates that external data feed. Now every tick, your agent can run this routine, get the data, and act on it.

The routine is simple code. Your agent can help you build it, and once built, you can use it everywhere. In the future, we’ll probably create a directory where you can share routines and find what others have created.

Technical Analysis Routine

Fede: Here’s one that sends pictures. This technical analysis routine analyzes trend, volatility, support and resistance. It uses the Hummingbot API to get candles, processes the data, and suggests grid parameters.

See the output—it’s detecting values and sending me charts. I was testing different methods of support and resistance analysis. There’s one that shows a comparison of all methods: Classic, Pivot, SciPy, Volume Profile. All this was created by Condor for me. Zero coding—just prompting and receiving feedback via pictures.

This is the power of routines. The agent isn’t using MCP tools and wasting tokens. It’s just modifying code that runs and gives you output.

Live Build: CoinTelegraph News Scraper

Mike: Let’s try something we haven’t tested beforehand. I’ve always wanted to experiment with ingesting news and having an agent interpret it for trading implications. This is sentiment analysis—hedge funds have done this for years, but it was hard because understanding news implications is complex.

Today with LLMs, interpreting textual data has gotten much better. If you give the LLM articles, it should be able to interpret the effect. Imagine some news happens—the US lifts a blockade, for example—that has immediate market impact. If an agent can pick up that information, interpret it, and adjust your bot, it’s monitoring news for you.

Getting news, interpreting correctly, and taking automatic actions isn’t trivial. Let’s see if a routine can help.

Fede: I’ll tell Condor: “I want to build a routine to analyze the news content provided by CoinTelegraph. Do some web search, parse the HTML, and structure the information.”

[Condor starts working]

Mike: If you have questions about routines, drop them in the chat. We’ll answer them live.

Fede: It created the routine. There’s an issue importing Beautiful Soup—let me tell it there’s a dependency issue.

[Debugging]

Mike: I promise we didn’t test this beforehand. We want to respect the sanctity of the live stream—whatever happens, we deal with it.

Fede: It’s working now. Let me run it... CoinTelegraph latest news, fetched five articles. It wrote the routine without us writing any lines of code.

Now I’ll say: “Run the routine getting 15 news articles and detect if there’s information about an interesting token to trade.”

Mike: Just say Bitcoin since it’s likely to be mentioned most.

Fede: Here’s the analysis... NEO comes up. “CEX volumes down 39% in Q1, macro crypto winter narrative. NEO—clear catalyst, treasury restructuring. Fundamental change. Treasury overhaul is material, likely to drive short-term volatility.”

Mike: NEO! I haven’t heard that mentioned in five years. For the old school crypto people, NEO was an Ethereum competitor back in 2017—a Chinese smart contract platform. Ethereum won that market, but it’s interesting they’re still around.

From News to Trade

Fede: Let me run technical analysis on NEO. The TA shows NEO is in tight consolidation with low volatility. The news catalyst hasn’t hit the price yet—it’s either cooling for a breakout or the market doesn’t care yet. The range is very tight, tricky for directional trades but could work for a grid.

Let me get a longer timeframe—one month with 1-hour candles.

[Routine updates to support different timeframes]

See that? You can be on the beach with your phone talking to Condor, making it write Python files for you that use Hummingbot. Schedule reports every hour, whatever you want.

Mike: A question from chat: “Can routines use cheaper local LLMs for execution while the orchestrator stays on frontier?”

Fede: That’s exactly what routines do. The execution is not LLM-based—it’s just Python code. The frontier model creates the Python code and triggers execution. That’s the point: saving costs because that part is just code running. All the scraping of CoinTelegraph was done by the frontier model once. Now it just calls the routine—Python code that’s not loaded into context, just executed in runtime.

Mike: We’re experimenting with adding open source models to Condor. The end state: you use frontier models to build your agents and write routines, but when running the agents, you use a local model for runtime to avoid expensive tokens every time.

Fede: Here’s NEO—it’s proposing a long grid from $2.84 to $3.46. I want a wider range, up to $3.70. Total amount: $500. Max orders per batch: one. Take profit: 0.1%. Keep position: true. Coerce TP to step.

Deploy.

Mike: Nice. The NEO long grid is live. How many open orders?

Fede: Five. Here’s the position. It’s a 44% range, so it’ll be more of a mid-frequency grid. But look what we did: we made a routine that gets news from CoinTelegraph, ran a routine to analyze the assets technically, and deployed a grid. These are things you can do as a trader manually. Next week, we’ll do the same but with an agent automating it.

Wrap-up & Episode 4 Preview

Mike: Let me summarize what we did today.

First, we went over new improvements in the Condor UI—specifically the trade tab where you can place individual executors. These are the same things you’ll program your agents to do.

Second, we covered the concept of a routine: deterministic Python code you can run and schedule in Telegram, and have your agents use. Today we focused on using routines standalone for daily monitoring reports, market updates, and things you want to schedule regularly.

Next week, we’ll show how to use Agent Builder to have your agent write a routine that fetches data every tick and uses that data for decision-making.

Routines are powerful because unlike skills, they’re simple deterministic programs your agent can write for you and use in a variety of ways. Over time, we’ll probably have a way for people to share routines and import them from others.

That wraps up this week’s episode. We’ll be back next Friday at 9am Pacific. Scan the QR code for updates on Bot Pod episodes and monthly releases of Hummingbot and Condor.

Fede: Thank you!

Mike: Thanks everyone for joining. See you next week.

Fede: Bye bye!

We’re back with Episode 2 of The Bot Pod! This week, Mike and Fede take a deep dive into Condor’s session management, review the results of the agent they built live on Episode 1, and demonstrate the full workflow from manual grid trading to autonomous agent deployment.

Also, we’re excited to incorporate AI agentic trading into Botcamp, our online bootcamp for algo traders and market makers. Cohort 13 of Botcamp starts on April 21, and we’re hosting open cohort preview and welcome session. We welcome cohort participants, Botcamp alumni, and anyone interested in learning algo trading or market making to join: Botcamp Cohort 13 Info Session

Watch the full episode: YouTube View the new Condor documentation: Condor

Episode Highlights

5:00 Episode 1 Agent Results: $25 Profit

Fede reveals the results: the scalping agent from Episode 1 made $25 profit with $9K in volume across 91 trades. They walk through:

• Session snapshots: Full inspection of every tick, system prompt, and agent reasoning

• New chart visualization: 30-minute windows around each executor for analysis

• Trailing stop improvement: When no upper resistance exists, use trailing stop instead

10:00 Agent Learning in Action

The agent has been evolving through its learnings file. Example learning: “Price below EMA 7 and EMA 25 while EMA 7 is higher than EMA 25 indicates weakness—avoid entries into declining moves.” These learnings persist across sessions, creating a self-improving system.

11:00 What is Condor?

Mike explains for newcomers: Condor is the next-generation interface for Hummingbot. It’s open source (MIT licensed), similar in architecture to OpenClaw, but focused on trading tasks. It runs on top of your LLM and connects directly to exchange infrastructure.

16:00 Live Grid Trading on Binance

A live demonstration of deploying a $500 long grid on a volatile market:

• Orders placing and filling so fast Binance UI can’t keep up

• Real-time P&L tracking in Condor

• All orders as post-only (maker orders) for better fees

23:00 Hyperliquid RWA Markets

Mike explores Hyperliquid’s new HIP-3 markets—real-world assets like WTI crude oil trading 24/7 as perpetuals. These are now the third most active markets on Hyperliquid behind BTC and ETH. Important gotcha: the ticker format requires the issuer prefix (e.g., XYZ:CL-USD).

34:00 Grid Executor Deep Dive

Fede walks through every grid parameter in the web UI:

• Start/End Price: The grid boundaries

• Limit Price: Stop-loss level for the grid

• Keep Position: True = hold inventory after grid ends; False = liquidate and start fresh

• Leverage: Configure directly in advanced settings

• Coerce TP to Step: Automatically adjust take profit to match grid step size

49:00 Building a Grid Scalper Agent

Mike creates a new agent from scratch using Agent Builder:

1. Strategy: Grid trading, both long and short

2. Risk tolerance: High (scalping)

3. Budget: $300 with 10x leverage

4. Tick frequency: 60 seconds

1:02:00 Live Trading Session

The new grid scalper agent goes live on Hyperliquid’s oil market. They watch it:

• Analyze spreads and market conditions

• Deploy a long grid when conditions align

• Monitor through the web dashboard’s real-time snapshots

Resources

• Condor Repository: github.com/hummingbot/condor

• Condor Documentation: condor.hummingbot.org

• Hummingbot Discord: discord.gg/hummingbot

Watch Live Every Friday

The Bot Pod streams live every Friday at:

• 9:00 AM Pacific / 12:00 PM Eastern

• Late afternoon in South America

• Late evening in Europe and Asia

Catch us on YouTube, Twitch, and X (Twitter).

Full Transcript

Episode Start

Mike: All right everyone, now we’re actually finally streaming with Fede. Let me bring him over and we’ll start the proper stream for episode two.

This is the Bot Pod podcast and we are the maintainers of Hummingbot, the open source framework for crypto trading and algo trading. We’re a bit discombobulated because we’ve actually been streaming just to ourselves for the past hour—I never hit the Go Live button on the stream.

I was actually wondering why no one was chatting. I thought we were just doing a bad job of making the thing interesting. But anyway, now we are streaming. I’m not sure how many people are actually watching now, but we’ll stream and get this recorded and edited for later consumption.

What we want to do today is go over the results of the scalping agent that Fede started in the first session. But before I go on, let me explain what this is and why we’re doing this.

The Bot Pod podcast is a weekly deep dive into the intersection of AI and crypto trading. We’re engineers at heart—we’re not marketers as you can see—but every week we’re building new stuff. And the new stuff we’re building is usually open source because we maintain this open source framework.

Lately we’ve been making changes to Hummingbot to make it more AI-friendly. I think now’s a good time to start demoing what these AI features are because it’s ready for prime time. In the past you had to be basically a Python developer in order to code up sophisticated strategies using Hummingbot.

But now with AI, anyone can do that. And because of how fast AI models are improving, we think the sky’s the limit in terms of what AI can actually do. However, you have to apply it in a structured way because it’s easy to create a demo—it’s much harder to manage and deploy a fleet of trading agents that are all acting in isolation, doing the things you want them to do and not other things, and keeping the whole setup secure and isolated.

Fede, how you doing?

Fede: Very good. Is the first time that we’re doing episode two? No, it was really fun.

Mike: We actually rehearsed what we’re going to present for this, so I think it should go smoother now that we had a dress rehearsal for the past hour.

So today what we want to cover is first go over the results of Fede’s agent from last time. We’ll also look at the structure of the agent again, and look at how the new UI presents the sessions, the snapshots, and the journal of the agent. You can also start analyzing what the agent’s doing. After that, I think it’d be a good time for me to show Condor from the perspective of a first time user and demo how you can do simple trades with Condor as well as more complex executors.

Before we dive in, I should mention there’s a QR code in the upper right hand corner that points to an info session we’re doing for our next cohort of Botcamp, Cohort 13. That info session is next Tuesday, so make sure to scan it and join for free.

What we’re going to cover is basically what we teach in Botcamp. Our view is that you have to learn the theory first of how to do various types of trading strategies like market making, arbitrage, and even more complex ones like cross-exchange and funding rate arbitrage and incorporating DeFi.

But once you understand the theory, you can start applying it into a framework like Hummingbot and using Condor to build more sophisticated trading bots. That’s why we offer this four week online bootcamp. If you’re interested, please scan the QR code or go to the botcamp.xyz website to find out more.

Fede, why don’t we start by demoing what happened with the agent you started last time and what you learned from it.

Reviewing Episode 1’s Agent Results

Fede: Let me share a screen. Can you see it?

Mike: Yep, I can see it now.

Fede: As you can see, I’m using Condor and with the command /web we get a link that I can put here. We can see this view. I did some improvements to the speed—I improved the caching with executors and all that stuff. I also isolated the positions that we’re going to talk a lot about in a second, but I wanted to show this agent that I’ve been working on.

This is the one we created last time. We have different sessions that I’ll explain. Basically we have this agent where we defined a strategy together, and we defined the routine that the agent will use. This is to avoid having the agent writing code on demand and taking a lot of time for that.

What we have is a process with the Agent Builder where we define what data is needed, and with that, we created this routine—a Python file that will process the data for us. In this case, this routine gives us the support and resistance levels.

Then it takes a decision, and this is what we defined with the Agent Builder last time. When we start a trading session, basically what we’re doing is getting that strategy, adding trading context (which in this case is not used), and then the session starts. It generated a few learnings.

Session three—that we started together—made $25. I have larger ones, but this one made $25, which was good. It also traded $9K in volume across 91 trades.

Let’s inspect the session. This was session three. I added this chart where you can see it filters 30 minutes before and 30 minutes after the last executor.

If we zoom, we’ll see the executors coming here. You have the IDs, what was the P&L of them, so you can analyze all the executors that the agent created. We can also analyze activity and the snapshots. In the snapshot, as you can see: system prompt. This is what I showed last time—everything that entered the agent response. It ran for 852 ticks until I stopped it.

I also separated the dry run from here. I think last week it was all together, so now it’s separated. An interesting thing about these sessions is you can see different sessions and the executors on top here, but also if you want to inspect the executors, you can click on this position executor.

As you can see here, it will show only the candles around that executor. You can see the final situation. One thing I added was—because I was receiving messages from the bot saying “My signal is telling me long, but I don’t have any resistance on top to define the take profit.”

So I told the Agent Builder, “If there’s no take profit, use trailing stop,” and we finally have very good outputs here with session three.

These were trailing stops. There was no upper bound before, so it finally captured this long trend.

Also another interesting thing is we can see the learnings. This is the learnings that the session was generating. For example, here there is one: “Price below EMA 7 and EMA 25 while the EMA 7 is higher than the EMA 25—lagging bullish indicates weakness momentum. Adding this price extra feature avoids entries into declining moves.”

All these learnings are appended to the same prompt. So the agent is self-evolving with these learnings that it has. As you can see here, it persists across sessions.

Mike: When does the agent write to the learnings?

Fede: It can write on any tick, but it will only do it if it’s new information or something that it thinks is valuable. So it would be information that the agent thinks is important and it’s not repeated.

Mike: Actually a question on the chat—maybe I can answer. “Hey guys, long time no see. I didn’t see the first episode. Could you repeat what is Condor exactly? Did you develop it or is it an external tool?”

Great question. Yeah we should probably have led with that. But yeah, for those of you who don’t know, Condor is basically the next generation interface for Hummingbot. So it’s open source. It’s by us. And just like everything else we do at Hummingbot it is open source and free.

I think Condor is actually under MIT license. But what that means is you can just go to github.com/hummingbot/condor, and you can just install it and it runs. It will run basically on top of your LLM and use exchange infrastructure directly to help you do trades.

So you can think—in terms of design, Condor has a very similar architecture to OpenClaw in that it’s an open source harness for helping your AI agent accomplish tasks for you. In this case these tasks are trading focused and we’ve also developed this web-based dashboard view to help you observe and inspect all of the things your agents are doing.

Yeah. So yeah. As you can see, we’ve also developed it for traders because we’re traders. We use Telegram bots all the time because it is Telegram native. We’ve also added like a trading interface. You can just do trades and do the basic things that you would want from a Telegram trading bot.

Fede: Yeah. You can also deploy grids from here directly. It is complete in that sense. You can say, “Okay, I want to place the grid from here and start here.”

And it will create a grid executor. And the beautiful thing is it works on all the platforms that is supported by Hummingbot.

You can run a long grid on Binance and a short grid on Hyperliquid perpetual. And it will work. So yeah. This is about agents. And I remember for the first session that was interrupted, you asked me, Mike, what are the potential improvements that I will do to this?

Mike: Yeah.

Fede: I started creating this one. My point was, okay, this was really nice. I like a lot the fact that it made some money. Two things here. I’ll work on probably the understanding, okay, how many tokens is consuming, to see if it’s taking a lot of data or not. And then I’m doing some tests to try to replace it by local models.

I already was testing QWen 3.5, the smaller version, and it returned like some Chinese, so it was—this one was correct. But I need to verify that it is working well. That’s one thing, like trying to make it work with local models or a fine-tuned model that then Hummingbot users can get.

And the second thing is that I was trying to say, okay, where am I trading here? I am trading on volatile markets that in that day AIOT had a lot of volatility, but I want to scalp or trade on markets that are really moving, right?

So for that they need like a screener or something to check all the markets how they’re moving or where they are. Like where is the volatility. So for that, I gave Condor an endpoint to get all the tickers and the movement of the last hours of the markets.

So my point was like, okay, I should encapsulate that into a routine and just run it to see which are those markets. So I don’t need to do analysis by myself. So now if I tell Condor, “Run the top movers routine,” it would help me doing this exploration of markets in a more automated way and also in an AI way. So then I can just tell the AI to do the next step.

So as you can see, it’s telling me, okay, these are the markets that have this volume and all stuff. So now I can say, okay, “Can you run the market analysis on ARIA USDT?”

This is another routine that I created that analyzes data for a specific market. So what’s my point here? The routines are Python files that you can create with Condor that will use any external source, or will use the Hummingbot API directly to encapsulate some analysis that you want to do that can be generated with AI using Hummingbot API or any external source, and it’s going to be useful for you.

Then you can, for example, now that I have the top movers and I have also this chart that is telling me where is the grid that I want to generate—I can just deploy a grid from here.

So it’s recommending a long grid. That can be risky in this scenario. But I would say, yeah, propose a grid long grid from the support to the top. I want it to be in a range of 10% max. And put, I don’t know, let’s say 500 USD on it.

So the point is okay, now that I’m trying to get more familiar with the process, I want to see how it’s—let me see the range. Okay.

Use take profit of 7.2%, let’s say, and keep position equal to false. And then if I go here to Binance and I say to deploy, yes.

What market was ARIA?

Mike: ARIA.

Fede: It failed. Maybe it’s because I don’t have enough balance. Let me see.

So if it fails, you can see what happened. So see, these markets are probably the ones that I want to trade. We agreed. There it is. It’s moving 1%. It’s 7.3% per second is moving—this type of markets, right? They’re really risky, but they’re also like intermediate via take profit.

I think that it’s using all the information. I would say start certain point. Move N to zero points 57.

It was suggesting a price that was below. Yes. Okay. Now it seems like it’s actually trading. Let me submit this.

I think that I need to—it’s moving that so fast that we can’t even see the orders. The orders placed.

Mike: So your order history here should show all your—okay, I see. I see your open orders. So it’s basically placing and canceling the orders around the price.

Fede: These arrows are fills, so these are filling orders already. But yeah, it’s trading.

Mike: So what you’re trading here—it’s a grid between what prices? Are your—it is a buy grid, right? So—

Fede: If I go here to executors, I will see this buy grid that is between these two prices, between the 57 and 40.

Mike: And 0.9?

Fede: 0.9, 0.9. If it reaches this value, I will be taking profit.

Mike: Okay.

Fede: But yeah, for now it is between those levels.

And yeah, see that it is nice that this value is also updated in real time. It traded already like $300. So I almost see like a turnover of the assets. But yeah, this interesting thing about this—the more the market is moving is also another issue is that I put 0.2 of take profit.

I could also put 0.4% because see how big the market is moving. So my point here would be like, how can I start setting better and better values for the limits of the take profit, of the stop loss, all that stuff.

Also another interesting thing is that all these—let me see all history. That all of them are post only orders. So all like limit orders. It is important for the fees.

And see that the UI is moving so fast that it cannot keep track. Binance can’t keep track of the orders that I am placing that are much more than these ones.

Mike: Can you go to the—can you go again to the view of this in Condor to see what information Condor has? So does this also show you the volume and the fees? Yeah. Can you show what information is shown there?

Fede: Yeah. Here it’s showing the net P&L, the core net P&L, the volume. Okay. The fees that I paid already, the end price, the start price of the grid, some custom info. But maybe you will just see this, like at this view: buy, the P&L, the P&L percentage, the volume traded and the fees.

Okay. This is probably what you will see right now. But yeah, it seems like it’s moving very fast. Like this asset, this market—actually I think that it should be more volume than 600 dollars. I’ll ask Condor what’s the state of the grid?

Mike: I see.

Fede: Yeah, I see. Yeah, because some of the positions are like position hold.

Mike: Yeah. So it seems—yeah I think one easy place to start with Condor is just starting to use it for simple manually placed grids using either the Telegram interface or using the web interface.

Fede: Yeah. I think that placing grids directly from Condor is like a good starting point because you can do it on spot, on perps at the same time. You can do it very fast and generate volume or trade and generate profits depending on where the market goes. And yeah, I think that is a good starting point. Because it’s easier to understand—for anyone that wants to run a grid, it would be very simple.

Mike: Okay. Maybe another time to segue into the next part of what we can do. So let me answer one question from the chat. I think Joshua said he has a couple questions about where to learn. And if we train a local model what would be better.

Yeah, let me show my screen. I can go into what that looks like. Let me share the screen here.

Hyperliquid RWA Markets Demo

Mike: Share my screen. Okay. So here yeah, I want to share the perspective of a user of just like a new user—especially because I’m quite interested in trying to see if I can run an agent on this market here on Hyperliquid.

This is the oil futures market on Hyperliquid. Recently people have been trading these HIP-3 markets quite a lot. So now you can see this market, this WTI oil, is actually the third most active market on Hyperliquid just behind BTC and ETH. And the reason is because these markets are more liquid now. They trade 24/7.

So I think for a lot of the TradFi folks out there who were used to trade these on the CME, now they’re trading on Hyperliquid and other crypto venues.

So these are perpetual markets and now they’re all supported in Hummingbot. As of a couple releases ago, HIP-3 markets are now supported. There are some tweaks with the ticker because this market has an issuer. The issuer is TradeXYZ, but there might be other issuers that are trading other kinds of real world assets—there might be other issuers like Cashier as well.

So when you represent the ticker for this market in Hummingbot, you have to use the issuer colon, and then the trading pair to fetch it. That’s a bit of a gotcha. But we should be able to improve either the MCP layer or the API layer to better handle this in the future.

All right. So the first thing I’m gonna try to do is go into Condor here. And actually I had created one earlier during the dress rehearsal livestream.

So back then I created an order executor. So that’s the position you see right here.

And if I go into my Condor, my web interface, let me do that.

Here I can also see the executor—the position that the executor has created right here. Yeah, because I just started a new instance of Condor. The executor has stopped, but it moved that position here into positions because I still have the position active. And it’s one that I’ve kept around as inventory that this process has maintained.

So this position feature you’ll see us use—it’s what allows each agent to isolate its impact on your portfolio from other agents. And so you can think of the positions for every agent—I think we’re also gonna rename this “inventory”—but to track the virtual portfolio that each agent has acquired and the agent can make decisions about what to do.

For example, as a market maker, maybe after you’ve acquired—

Fede: Mike. Mike can you zoom in that page? Are you sharing from your Mac or from your external monitor?

Mike: I’m sharing from my external monitor.

Fede: It is better to share probably from the Mac because of the resolution.

Mike: Oh, okay. Got it. I see what you mean.

Fede: In the meanwhile, I’ll reply. Yeah, deploying a bot from the trained agent will be something that we can do soon. Right now you can deploy bots from Condor. Right now, I’m currently doing that with my friends. We are running bots for customers. We are managing all the bots through Condor.

With all the bots, we deploy all the controllers. We have Condor analyze the controller performance. We can edit the controller configs through Condor and then redeploy. So that’s a question for that.

And regarding back testing, I am adding back testing. I am going to add—I’m currently doing that—back testing for grids. And I also added the position hold to the back testing. So yeah, that will be an improvement that will probably be available next week.

Mike: Do—yeah. But yeah. So this position concept I think is actually an important one. Actually, if you want to learn more you can go to the new Condor website, which was just published yesterday.

The website is condor.hummingbot.org. I’ll put it in Restream chat right here.

But basically this website—it’s AI generated. It is based on the current branch, Hummingbot API and Condor. So it should be relatively up to date. But our team will be polishing and checking it over the next four weeks. But it should give you an introduction into what Condor is, getting started with installing both Hummingbot API and Condor, integrating your LLM.

So right now we recommend using it with Claude. But we’ve tested it with Gemini and Codex as well. And we’re also playing around with some other local models.

Fede: But—

Mike: It should work well with Claude. Now, one reason is because Condor actually just uses Claude Code under the hood. So it’s basically a meta harness, and so you can actually start the same session from Claude that you have with Condor.

I can show that later. But basically if you’re logged in to Claude Code and then you start Condor, it should automatically work because you’ve already connected to Claude Code. But let us know in the chat or in GitHub if you have any issues.

But after that, you probably want to add your credentials either spot or perpetual keys with the keys command. And then after you’ve added credentials, you should be able to see your portfolio using either the portfolio command or in the web view.

So once you’ve done that, you can explore the other functionalities. For example, you can do trading, you may want to manage Gateway and do operational indexes like LPing. And you can run bots.

So bots are basically the traditional kind of Hummingbot strategies where you define deterministically what the logic is. And it runs deterministically.

You can run bots already, I believe, through the Condor web interface here in the bot menu. But we haven’t fully tested all this out yet. This is like—we actually used to have a dashboard in Hummingbot that allowed you to deploy bots. And this bots page in the new Condor web interface is basically a replacement for that dashboard.

However, I think the more interesting thing that we want to explore is what you can do with agents like the one that Fede built last time. So yeah, just as a recap—I wanted to do more with this WTI market on Hyperliquid.

So first, the first thing I’m gonna try to do—actually, I think we’ll just place a grid on this market.

Yeah, the ticker is CL USD, but I think in Condor I need to call it different, right? I have to give it a different name to get—let’s see actually, let me get my portfolio first. Make sure I have access to my portfolio.

Let’s see. I think it’s a bit slow because it has to check my Ethereum balances. Yeah, it’s getting the quote from Ethereum tokens right now. That’s why it’s a bit slower. If I had just connected centralized exchanges and Hyperliquid, it would probably be a lot faster. But it’s fetching the quote right now.

It’s still fetching the web quote. So now it has a quote. So now it has prices for all assets in my portfolio, and you can see now I can see the balances and the current values of all my assets.

So I think the unique feature about Hummingbot is that we integrate to pretty much every single exchange and blockchain out there.

So that’s why I can see my balances on both Hyperliquid—there’s other centralized exchanges like Binance that I could connect—but I can also see my assets on Solana and Ethereum networks as well.

So yeah, let me go into the web view and actually—yeah, before I actually, before I do that, let me go into agent mode. And then so I can talk to my agent. Actually do I need to go agent mode, Fede, or I can just say hi?

Fede: You can just say hi. The agent mode—you need to go if you want to restart the conversation or switch to the Agent Builder.

Mike: Okay. Okay.

Fede: Actually I think that if you send a dash—enter that should also reset the session.

Mike: Cool, cool. Okay. So let me just—I’ll do what I would think I would do. So I’ll say: get me info on this WTI oil—

Fede: No, but WTI will not work because it’s not the right thing.

Mike: I know, right? I’m trying to demo this. Yeah, I know it’ll fail. I’m trying to demo what would happen if you actually did what you think you should do, which is just type in what’s on Hyperliquid into the chat.

Yeah, I want to demo this because there are unfortunately few gotchas with Hyperliquid and also the integration with Hummingbot. But yeah, this is something that—yeah, once you figure it out, it’ll be much, much clearer.

So right now it’s trying to find this ticker and what it’s actually doing under the hood. It’s looking at the trading rules for Hyperliquid, which has a list of all the tickers, and it’s just trying to match this ticker to find.

Yeah, so CL was not able to find the market. So there’s a couple of things here that we have to go—actually this is—I was actually using this skill that I had called “connections available.”

But actually let me give it some more hints. I think the CL USD market on—yeah, because the ticker is actually CL for those of you—oh, actually, so now I actually did find more markets. Okay. Because this actually—the value of Condor—because it can do some analysis on what it finds.

And it did find the markets in the right convention. So in Hummingbot, because of the issuer, the convention is issuer colon, and then the trading pair. So actually let me—did you, yeah did you remove yourself or was it—

Fede: No. It was a very small interruption that the system went down for 30 seconds, but I never came back.

Mike: Okay. Now you’re back.

Okay. So yeah, I’m still the stream host, so yeah, I want to explain that. Yeah. So actually, look, it actually did find some tickers in the right format.

Yeah. I think I actually want to use XYZ:CL-USD—check prices. So yeah, so the right format is actually XYZ:CL-USD. This will basically allow Hummingbot to find the right ticker, fetch the right balance, and then be able to execute trades in that market.

Okay. So now it has a market. And so now I could place a grid executor like this or I could use the web interface, Fede, to do it.

Fede: Yeah.

Mike: Let me actually use the web interface because I think you did it the other way before.

Grid Executor Parameters Deep Dive

Mike: So now I go to the web interface here. I can go to executors and then do a new grid executor to place a grid executor in a market.

And here is the market on Hyperliquid. So now I can already see the market on Hyperliquid. This is basically the same information that I would see if I went to the Hyperliquid market. Except again, this is a little more streamlined, slimmed down. But this is coming from the same information as in the markets tab.

Okay. So now if I wanted to place a grid—so here, which should I click on?

Fede: I think that you can start with auto field right here, right?

Mike: Yeah.

Fede: With auto field will let you suggest some values. Probably I would recommend to lower down—click on the target icon of end price and click on the peak of that. It’s next to the chart a little bit left?

No, that one. No the one that is lower than that one. That one. Yeah. But you’re clicking in the edge. Please click again to the target. Click in the target. And click at the left. More left. More left. More left. Yeah. There.

Mike: Okay.

Fede: And then the grid amount. This is something that we were discussing.

Usually when you are—if you want to place like something like, let’s say 20, you need to know that will not make sense. Because if you are trading on a market that the minimum order amount is $10, you can’t put $20 because it will be just a grid of two levels.

So at least you will need to have 200 dollars of grid, let’s say.

Mike: So it’s basically—it’s because of the minimum. Your minimum order here on Hyperliquid would be like 10 or $11.

Fede: Yeah. And on Hyperliquid is 10, so I recommend to put 11. So you avoid rounding products.

Mike: So basically what you’re saying is the reason here is because it’s like here—I put $20, there’s 32 levels. So each level is—yeah it wouldn’t be—it would be lower than the minimum order amount. So that’s why—

Fede: No, that number of levels is inferred from the mean spread between orders.

Mike: Oh, okay.

Fede: So the mean spread between orders is telling you: with this mean spread, you’ll have 7.1. But there is also a restriction of the minimum order amount because the number of orders will be total amount divided by minimum order amount—will also be a restriction.

Mike: Can I also reduce the number of grid levels placed? Would that allow me to have a lower total amount?

Fede: No, because if you put 20 and your minimum order amount is 11, it will be still two orders or one order.

Fede: No—the total amount divided by the minimum order amount gives you the number of orders.

Mike: So here we’re placing around 20 orders. Would this configuration make sense?

Fede: Yeah, that would make sense.

And then take profit. You can put it in like 0.1, let’s say. You’re putting “coerce TP to step.” That check that says “coerce TP to step”—that makes that if your take profit ends up being lower than your step, your grid step, it will use the grid step.

Mike: So then this part’s not being used if I do this?

Fede: You will use that value of take profit.

Mike: Got it. Can you explain what “keep position” means?

Fede: There’s a value in the chart that says “limit”—that’s a limit price you can configure. And basically it means that the grid will be placed between the start and the end price.

All the orders will be in that zone, but if the price goes below the start price, you need to decide what you’re going to do with the grid because you acquired, in this case, a lot of base asset, right? Or position in this case, right?

So the limit price is a way to tell you, okay, this is enough for this grid. We’re going to close it. Okay? The thing is, you have two paths here with the grid. Or with the actions that you took.

One path is you’re going—you can reverse the trade. So you will assume the loss in this case because it’s going against your price. And the other is to just keep the position and then manage the position in a long term basis, right?

So that parameter that we were looking at, that is “keep position.” What it will do—it will say, okay, if keep position is true and the price reaches the limit price, I will keep my position entirely and then I will let the user manage it in a long term.

And if you do that, you’ll see that position in the positions tab that you have at the left.

If keep position is false, it will just sell all the assets that it bought and will be starting fresh. Okay.

Mike: So keeping position means keeping the inventory after this executor is over. If keep position is false, it reverses the trade and starts from a clean slate.

Fede: Exactly.

Mike: For perpetual positions, it’s actually quite intuitive. The executor is like one single, contained trading workflow.

Could be a single order, could be a grid of orders. And when a grid is done—do you want to keep the position you accumulated or not? Or do you want to reverse it? Okay.

Yeah. So yeah. Now I’m ready to place my grid. And yeah I think I do want to keep the position. I think if it hits the limit—actually, actually no, I don’t actually, because I’ll probably be running this for a while. I don’t want to have to come back and remember to close the position.

So in this case, when it hits the limit, it would automatically close the position at market.

Mike: Okay, should I hit create now or is there anything else I need to be aware of?

Fede: I think that you can just hit create. There is advanced configuration there, but I don’t think that is needed now.

Mike: Let me close this position here on Hyperliquid first so we can see a clean slate. I have $500 in balance, which should be enough. Should I increase the leverage?

Fede: Put 10x.

Mike: So now it’s only gonna use $20 of my actual capital since the total grid amount is $200 with 10x leverage. Let’s create the grid.

Okay. It’s created. It looks like it’s created. And then on Hyperliquid, I should be able to see—Yep. Here are the orders that it created. Yeah, it created—this is a buy grid, so it’s created only long orders. Created them below the current price. So if the price goes down, it would create those orders and it’s already created a position already.

Cool. So now if I go to Condor—yeah. Let’s see. Yeah. This shows me the running grid executor here.

So let me see if I can just visualize this and try to understand this in my own words. So this is the start price here, the end price, and the limit price.

Awesome. So basically what that means is the grid—because it will buy orders here and each one of these buys is a position executor. So each one has a take profit level. What happens if the price exceeds this value?

Fede: It would be closed at take profit. You end up with zero positions.

Mike: Got it. Is there a time limit on this executor?

Fede: I think you can define one, but I don’t use it.

Mike: The concept of the executor is that it packages nested trading workflows together.

Like here for example, it’s creating a grid. You could do this with single trades or call an API directly, but then you’re doing a lot of things over and over again. So it abstracts this trading workflow into a single package and it ensures that what this executor is doing is isolated from what other executors are doing.

And when it closes, when it ends, you can decide whether to track the impact of that or not. And when you track the impact of it, it’s basically gonna create a position in what we’ll probably rename “inventory” in a few weeks.

And this inventory is what allows your agents to maintain isolation from each other. Because once you have an agent running, it acquires inventory by starting executors, stopping executors. And executors are what allow it to do different things on different exchanges while maintaining consistency in terms of how those are handled.

Because it means you can do a short position on a perpetual exchange, do a long buy order executor on a spot exchange. And the way those are handled all use the same kind of P&L dimensions. They all do the same reporting.

So your agents can create executors, stop them, and then have them all treated in the same way. So that’s really kind of—I think that’s why we standardize everything into this framework.

And the benefit is, I think you can run many agents at scale and then be sure that they’re all working alongside each other.

All right. My grid’s been running for a while. This custom info is what the executor is reporting.

Fede: That’s the raw config.

Mike: The raw configuration for the grid itself. The grid is still running and doing quite a lot—these are the take profits for the open positions. So far I’ve only lost 1 cent and it’s traded $46 of volume already.

Let me now go into Condor. Yeah, I think the last thing I want to cover today was just kind of starting some type of agent that would do this.

But so instead of me starting grids and just starting to manually—maybe building agents that would do this on Hyperliquid.

So actually let me stop this first before we proceed. So can I just hit the stop button to do it?

Fede: Yeah. But let it run until you finish the session.

Mike: Okay. To—yeah. So I’ll do that.

Building an Agent for Hyperliquid

Mike: So now let me build an agent that decides when to place these grids.

Fede: Go from Telegram. In the meanwhile, I’ll answer a few questions. The limit price is essentially a stop loss. If it makes sense to make it with dynamic price ranges based on EMAs—that’s exactly what you can do with the Agent Builder. With the agent mode, the idea is that we can create these trading agents that can deploy grids based on these dynamic things.

One can be the EMA that you are mentioning, Via My Life. And then there is no video to set up this dashboard with Ubuntu Linux. Yeah, maybe we can do these live streams to show that—maybe, but probably we can create this video doing it, right?

Mike: Yeah. Yeah. There’s a lot of—I would say we haven’t done that much on the front end for Hummingbot. We’ve been mostly working on the backend. So I think for those of you who want a dashboard kind of experience, this is basically like the—

Fede: But they’re asking for a video of how to do the setup.

Mike: If you have questions about setup, post them on GitHub. In the future we’ll make more infrastructure videos, but the goal of these live streams is to show what you can do with Hummingbot and Condor.

Now I’m familiar with creating grids through Condor and the web. Let’s create a proper agent using Agent Builder.

Fede: Go to agent, then switch mode to Agent Builder. Tell it you want to create an agent.

Mike: I want to create an agent that trades XYZ:CL-USD. It asks for strategy type, so I’ll say grid trading, both long and short, $300 budget, scalping style, high risk tolerance.

The recommended settings: 5x leverage with 10 grid levels per side, analyze volatility each tick, set grid bounds dynamically, limit maker orders, tick frequency every 60 seconds, max loss per tick $30. That seems reasonable.

Fede: Tell it you want to create a routine for the agent to analyze where to put the grids. That’s phase two—the market data routine.

Why is Agent Builder structured this way? First, you define your strategy briefly so the agent has context.

The second step is to code this market data routine. The first thing that you always want to do is to make sure that the market data that you’re using is correct and is doing what you want. So this will create a Python file that you can reproduce at any time, and then you can continue.

Once you have the data and you have the basic guidelines, you can define what the decision flow for your agent looks like. And then you have a way to test in dry run mode where you just see, okay, where the agent will be putting the order and stuff. And then it will finally let you run in loop or in run mode.

But it’s kind of aggressive—

Mike: It’s failing to fetch the order book—the issuer is being stripped out somehow.

Fede: It’s fixing the routine. This is exactly why you want routines—see how much time is spent until you finally get Python code that works. Now it works.

Mike: It had to fetch the right endpoints for candles and order book. The chart shows a bearish trend. Should I move on to phase three—dry run?

Fede: Yeah. There might be some rate oracle issues with those perps, but the PR I merged should fix that.

Mike: What is a dry run versus an actual run?

Fede: Dry run tests the reasoning of the agent without actually executing anything—just proposals. It’ll fetch data and run the routine, but won’t run any executors.

If you go to the website under agents, you’ll see your grid scalper agent. Click on the experiment to see all the data your agent is seeing. One thing—you can’t deploy two grids in Hyperliquid, so update the prompt to specify only one position at a time.

Mike: So it updates the Agent.md file?

Fede: Yeah, it will do it for you. It’s the actual strategy file.

Mike: This is cool—if you open the Condor folder, you see every agent in trading agents. Here’s my grid scalper agent with the dry run and routines. This routine analyzes the CL market on Hyperliquid and fetches the information needed for analysis.

Should I start for real?

Fede: Try another dry run first to verify it’s only proposing one grid. Stop the other grid you have running.

To answer Saul’s question—when you install Condor, it asks if you have Hummingbot API running. If not, it deploys Hummingbot API in Docker for you. Condor is installed with Python using UV, so you don’t need Anaconda.

Mike: Let’s look at the dry run. This is the second one—neutral long grid. Let’s start.

Fede: Clone the repo and follow installation steps. You need a Telegram bot token from BotFather and your user ID for security.

Mike: Cool. Let’s start the agent.

Agent started. It’s 60 seconds per tick. On the first tick, it sends Agent.md and other information to the LLM, runs the routine, and makes decisions.

Fede: Go to snapshots. Click on number one—the system prompt shows everything entering: strategy file, learnings, and other context.

Mike: It analyzed spreads and executed a long grid. But it says status closed with take profit—seems like it picked a wrong price.

Fede: Tell Condor you’re seeing grids closed by take profit at wrong prices. That will improve the Agent.md.

Mike: The strategy instructions were wrong. Let me fix and restart.

Session three is now placing orders in the CL market. There’s a couple of buys and sells, one position. Looks operational.

Fede: That’s correct. Let’s see the next tick. It should wait for that grid to end.

Mike: The grid just closed some orders.

You see what the grid actually—here, it looks like. So this saying the mid is 93.31—the grid is 93.31 to 94.23. Still start price. Okay.

Fede: Yeah. But see that down there says like a summary: “Existing long grid still valid. Price within range. P&L with limits. No replacement either.”

Mike: Yeah, no, actually this is pretty cool. Because I’ll be honest, I’m not an expert in grid trading. I only trade on Solana DEXs. I have no idea what I’m doing in terms of grid trading.

But now with this, I feel like I have a slightly better idea of what I’m doing, helping me deploy these grids and making sure that all the parameters are correct.

I’m happy to let this run and learn from the learnings it generates. Let me summarize: I used Condor to deploy grids manually and through the executor’s menu, then created an agent that deploys grids based on market data and learns over time.

I’ll let this run and review the results next time. Next episode we should cover routines—how to build custom routines is powerful for integrating external data sources or special indicators.

Fede: Sounds good.

Wrap-up and Q&A

Mike: Yeah. But finally I want to call out—yeah we are still running our Botcamp. Market Maker Bootcamp. So we have cohort 13 starting pretty soon.

There’s a QR code with an info session link that’s streaming right now on the upper right. That’s actually—I should probably mention this at the very beginning. That’s a free info session that we’re running for folks to get information about the cohort.

It also serves as a welcome session for those who are participating in the cohort. Because as you can see, we’ve made lots of changes to the Hummingbot open source framework. And we’ve revamped the curriculum entirely so we can start teaching how people can start creating trading bots using AI as well as the old fashioned way.

The Botcamp is still structured to teach you the theory of market making, algo trading, and arbitrage. We’ll learn different types of strategies that people employ in professional market making, and then we’ll also learn how to customize and build your own strategy.

And in the past, I think the one reason we’re excited about this Botcamp is because in the past you really had to be a Python developer in order to code up a truly sophisticated strategy.

But now with AI, it’s much easier to describe what you want. Keep on iterating on it—looking at what we just did—continuing crafting the Agent.md file and get to a point where your agent is even better than a deterministic strategy.

So that’s why I think what you’ll learn at Botcamp is basically all that in a compressed three—a little over a three week online boot camp.

And then after Botcamp, we’re gonna do our first agent training competition where people who’ve created the agents can run them, make the strategies publicly available, and then compete for prizes that are sponsored by exchanges and other crypto funds.

There’s information about that on the Botcamp website. So if interested, go to botcamp.xyz.

Fede: Yeah.

Mike: Let me answer a few more questions that we got from the community before we end.

I see one here from Saul, which is: “Is there any way to use Condor/Hummingbot to deploy strategies based on external data ingestion?”

Great question. That’s exactly what we’ll cover in the next episode. I think that’s the role of routines. I think the one that Fede demonstrated from Binance top movers—that was actually not using Hummingbot API data, it was a separate API that integrated to build that top mover’s routine.

So next week I think we’ll cover what is a routine, how you can use Condor to build it, and how you can pull in external data sources using your routines.

Fede: See, yeah I think that, Mike, that would be really good for the next session—like showing how we can get external data from a routine and do something with that. Like showing, okay, this is how you integrate this external data and this is how you can actually use it.

Fede: It terminated the previous grid and deployed a new one. It traded a bit. The terminated one ended up as position hold.

Mike: This is the inventory that this bot maintains—what I was referring to earlier.

So over time you may have more than one agent running and each agent will have its own kind of inventory positions that is maintained. And that’s how it can know—it can make decisions based on how much inventory is accumulated.

And you can track each agent separately and see which one’s doing what you want versus what you don’t want.

So yeah, again, this is all open source. It’s all free. But we think this is gonna be the next generation interface for Hummingbot. It still works the same old fashioned way. It is still a reliable execution layer across all exchanges.

And now we’ve also added blockchain networks—Solana, Ethereum as well. But in order to use it to manage a fleet of agents, what you want is something that can act reliably across all of these different markets in a standardized way.

That’s why we have this concept of positions and executors and so forth.

Actually, yeah I should—if you’re interested in more details, take a look at the Condor documentation. We have more information here on the architecture of a trading agent. Probably need to clean this up a bit but there’s more information here about why we design this trading agent structure in this way.

Because we think that if you’re actually gonna be running lots and lots of agents—if you want to set up a quant trading firm or a market making firm, you’ll likely be running lots of different separate processes. You’ll need to separate them all and do them in a proper fashion.

That’s why we built this trading agent framework.

And yeah, so read this to get a better understanding of it. But over the next few months, we’ll be adding different types of—more—we’ll build the framework, we’ll probably be adding different types of executors for you to do different things on different types of venues.

But we’ll try to make sure that all have the same way that they track P&L, how they track value. And every agent can decide—can track exactly which positions or how much inventory they have accumulated.

Because that way I think it allows one person or a small team to manage a larger and larger number of separate processes for different clients—or maybe some are for experimentation, some are for production.

So it allows you to manage multiple processes at once. But yeah, check this out. There’s also an API reference here.

Soon you’ll be able to try out any API endpoints directly from the docs. For example, to see what executors are available, you can get the types. You can do this through Swagger on your local API, or give your Claude or Codex access to this repo to understand which endpoints to call.

Condor is designed so you don’t need to call these API endpoints directly—there’s an MCP and tools layer that allows the LLM to call them. But sometimes you may want to call the API directly, and that’s where this reference comes in handy.

Yeah. One question—one final question from Zach. Zach says: “I did use a deployed repository to set up a VPS, but the dashboard is not working. How to fix.”

The dashboard probably should be working, but I think one reason why we built Condor is to basically replace kind of dashboard.

Basically what you probably want to be doing with dashboard is deploying bots—probably in the future, probably back testing as well. So back testing is not here yet but—but I think deploying bots is.

So if you want to just use a web-based interface to deploy bots, this is basically—this should be possible through this bots menu.

Overall, I would say we’re not gonna fully deprecate dashboard because it is still operational. We’re gonna put our focus into building Condor instead.

Fede: Don’t use the old deploy repo. Clone the Condor repo, set up the URL with your IP address and ports. If you have issues, ask in the Condor feedback channel on Discord—we fixed some issues this week.

Mike: We’ll update the docs to be consistent with Condor. It’s simple: go to github.com/hummingbot/condor, clone the repo, run make install and make run.

Thank you everyone for joining. Apologies it was an hour late—we had an accidental internal dress rehearsal. Next week we’ll review this grid scalper agent and cover how to create custom routines.

See you next time on The Bot Pod!

Fede: Bye-bye.

Fede: Alright. Bye-bye.

In this debut episode, we unveil Condor—our new open source harness for building autonomous trading agents. Watch us build and deploy a live trading agent from scratch, and see it place its first trade on air.

Watch the full episode: YouTube

Episode Highlights

What is Condor?

0:00 — Mike introduces The Bot Pod and explains why we’re building Condor: an agent harness similar to OpenClaw, but specifically designed for trading tasks. While OpenClaw focuses on general productivity, Condor is built for collecting market data, executing trades, and managing risk—all while talking to LLMs like Claude.

The Trading Agent Framework

9:00 — Fede breaks down how trading agents work, introducing the concept of a “tick” (one turn of the agent loop) and explaining the three possible outcomes: do nothing, stop an execution, or create a new position. He covers:

• Executors: Isolated trading units that standardize execution across 50+ exchange connectors

• The Prompt Structure: System prompt, Agent.md, Journal, Learnings, Routines, Tools, and Active Executors

• Three Run Modes: Dry run (no execution), Run once (single tick), and Loop (live trading)

Why Routines Matter

24:00 — Fede explains how routines (deterministic Python files) reduced agent reasoning time from 2 minutes to under 60 seconds by pre-processing market data instead of letting the LLM write code on the fly.

Python vs Rust for Trading

25:30 — Mike and Fede address the common question about performance. The real bottleneck isn’t Python—it’s network latency (200ms) and LLM response times. Fede also shares a sneak peek at Hermes, a Rust-based system achieving sub-0.1ms processing times.

Live Condor Demo

33:00 — Fede demonstrates Condor in action via Telegram:

• Checking balances across exchanges

• Running technical analysis routines

• Deploying a grid executor with a single chat message

• Using the new React-based web dashboard

Botcamp Cohort 13 & AI Trading Competition

43:30 — Mike announces Botcamp Cohort 13, starting April 21st. This cohort culminates in an AI Agent Trading Competition with $13,000+ in prizes from exchange and fund sponsors. Use code INFOSESH25 for 25% off.

Building an Agent Live with Agent Builder

49:00 — The highlight of the episode: Fede walks through the Agent Builder to create a perps scalping strategy from scratch:

1. Phase 1: Define strategy (scalping perps with tight stops on AIOT-USDT)

2. Phase 2: Create analysis routine (support/resistance + EMAs)

3. Phase 3: Generate Agent.md with decision logic

4. Phase 4: Test with dry runs

5. Phase 5: Deploy live

First Agent Trade on The Bot Pod

1:10:30 — The agent places its first live trade! We watch it identify a bullish trend flip, open a long position with take profit, and (spoiler) hit its stop loss. This leads to a discussion about agent learning and how the Learnings.md file allows agents to improve over time.

Agent Isolation & Scaling

1:12:00 — Fede explains how executor ownership enables complete isolation between agents. Each agent has its own virtual portfolio and executors, allowing you to run 10+ agents in parallel without conflicts.

Key Takeaways

1. Condor is free and open source — Clone it from github.com/hummingbot/condor and start building today

2. Structure beats flexibility — Executors and routines provide guardrails that prevent agents from doing “random things on your account”

3. Observability is critical — Every agent tick is captured in snapshots showing the full prompt, reasoning, and actions taken

4. Learning is built in — The Journal tracks session-specific memory while Learnings.md persists insights across all trading sessions

5. Multiple LLMs supported — Works with Claude, Codex, Gemini, OpenAI, and soon Ollama for local models

Resources

• Condor Repository: github.com/hummingbot/condor

• Botcamp Cohort 13: botcamp.xyz (use code INFOSESH25 for 25% off)

• Discord: discord.gg/hummingbot

Watch Live Every Friday

The Bot Pod streams live every Friday at:

• 9:00 AM Pacific / 12:00 PM Eastern

• Late afternoon in South America

• Late evening in Europe and Asia

Catch us on YouTube, Twitch, and X (Twitter).

Full Transcript

Show Kickoff and Goals

0:00

Mike: Welcome everyone! This is the first ever episode of The Bot Pod. I’m Mike, and we have Fede here. We’re the maintainers of the Hummingbot open source framework, which helps you automate your crypto trading. Hopefully you can hear us.

We’re coming at you live from our respective home offices. I’m based in California and Fede is based in Mar del Plata, Argentina. Looks like we have some people joining already, so feel free to ask your questions in the chat.

We have a user asking: “Is it possible to make a minimum of $100 in profit per day?” We actually get this question a lot. I would say it’s definitely possible—like any kind of trading, your reward is tied to the level of risk you take. You could have a million dollars, run a very safe strategy, and make $100 a day. But if you’re starting with $1,000 and want to make $100 a day, then you have to take a lot of risk.

1:00 That’s one thing we try to teach people. We also have an educational platform called Botcamp that uses the open source framework to teach trading and market making. One of the principles we try to teach is that trading is not a black box. It’s not just something where you put money in and money comes out the other side. There’s an art and science to creating a proper trading strategy.

Anyway, I want to give Fede a chance to introduce himself as well, because he’ll be doing the main screen share today.

2:00

Fede: Yeah, I’m Fede, I’m from Argentina. I’m the CTO of Hummingbot. I’m really excited about what’s happening right now in the AI landscape. It’s really interesting—every day something new comes out. It’s a great time to be alive.

Today we’ll show some of the advances we’ve been making on our trading agent. We really think you should use a specific framework designed for agent trading rather than a general one. That’s what we’re trying to build. We’re constantly reviewing all the different solutions out there, trying to create the best one we can.

We think we’re on a good path. We’re finally creating our first agents. I’m really excited 3:00 to be here, and we’ll try to learn as much as we can from your feedback and improve it every day.

Mike: Yeah, I apologize—I was a bit remiss in not explaining what this is. We’ve actually been doing weekly livestreams here at Hummingbot for many years, even since before the pandemic. But now that we’re building at the intersection of AI and crypto trading, we think this is a subject that a lot of people are interested in.

So we’re turning this into a weekly podcast. We’ll do about a one-hour demo of what we’re working on, demo some agents running in the wild built using our framework, and also explain some theory about why these agents are built the way they are. 4:00 So you can learn how to build agents for yourself.

Because of AI, it really lowers the barrier to entry. Before, people had to write a lot of Python code to create a sophisticated market making strategy. But today you can just talk to your agent, and the agent can build customized rules or interact with different exchanges. Having a structure like what we’re going to show you will make that process a lot easier, more scalable, and more reliable—which is what you want from your agent.

All right, so we’ll try to keep this under one hour and leave time for audience questions. 5:00 Maybe you can even demo what you’re building with Hummingbot as well.

Hummingbot has been around for a few years now. It’s one of the open source frameworks that many individual traders as well as trading firms use in crypto. The reason they use it is because it has integrations to many different types of exchanges—centralized exchanges, decentralized exchanges, and even blockchain networks like Solana and Ethereum.

What this means is you can write one type of strategy like market making and have it run on many different venues. You can even do cross-exchange, cross-venue market making, arbitrage, and trading. So Hummingbot is a great execution layer. 6:00 It can execute strategies on lots of different exchanges reliably and in a standardized way.

But now with the power of LLMs, you can have an intelligent model helping you make decisions, collecting data from the market, and helping you run strategies even better. That’s why I think the potential of these agents is huge—especially if you think about having some agents doing research, some doing simulations, others doing trading, and having them interact.

So there’s a lot of potential in applying agents to trading. But how do you make it all work together? That’s the question. It’s easy to create a simple demo, but as most algo traders and market makers know, if you really want to make money over the long term, you have to build a systematic approach. You need to calculate P&L accurately across different exchanges. 7:00 You need the agent to actually learn from what it’s doing systematically.

Think about if you want to run a hundred agents—how do all these agents operate both independently but also work together? These are questions we think about when applying AI to algo trading.

That’s why we’ve started to create our own agent framework—both a standard for defining what a trading agent is, as well as a harness, a system that can help you create, build, and run these trading agents. That’s what we’re going to demo today.

We built this system called Condor, which is similar in setup to OpenClaw. It’s an agent harness that runs on a server like a Mac mini, your local machine, or a cloud server. 8:00 It talks to LLMs like Claude or Codex, and it also does other tasks for you.

OpenClaw is really focused on general productivity tasks like managing your email. Whereas Condor is focused on trading tasks—collecting data from different exchanges, executing trades on those exchanges—but it also talks to LLMs as well.

This idea of a harness—a system that helps you accomplish something using LLMs—is really powerful. OpenClaw has obviously taken off, but we think there’s room for many other types of harnesses focused on specific tasks.

If you’re doing trading tasks, you may not want the open, possibly insecure mode of doing things the way OpenClaw does. Maybe you want something where the trade execution is separated from the agent layer, which is how Condor is structured.

So that’s the rationale for what we’re building—the concept of the harness and this trading agent standard that we’ll be showing. 9:00 Enough intro—let me hand it over to Fede who’s going to walk you through the structure of what we’re building and demo what a trading agent actually looks like.

Trading Agent Framework Basics

9:00

Fede: Yeah, I think we’re going to start with a simple demonstration—an intuition about what we’re going to talk about. Mainly conceptually, to explain the infrastructure that’s going to run.

We’ve been doing auto trading for a long time already. Usually you have a strategy you want to run—or actually a set of strategies: strategy one, strategy two, strategy three, whatever. But there’s always a basic process. 10:00

The simplest structure is: you have market data at some point. This market data can be anything—OHLCs, order book, trades, funding rates, on-chain token logs. Any data you want to incorporate. And you also have execution decisions that you need to take.

So a normal strategy starts here: it will gather market data from one side, and from the other side it will analyze current execution data or trading data. 11:00 For example: Did my strategy create an order before? Does my strategy have a position? All that information you want to know before taking the next decision.

Once you do this (which can be done in parallel), you end up at a point where your strategy gets these two things and decides: What should I do?

Then you have three potential outcomes:

1. Do nothing - because there’s an active action you want to keep

2. Stop an execution (we call them executors, but I’m talking more generally) - stop this position

3. Create - create this order, create this position 12:00

So you can do a bunch of different things once you understand the current state of the market and your current execution data. In any trading strategy, you have these two sources: the public data, your private data, and based on that you take a decision.

Mike: Yeah, just to put a point on this—this is what we call a “tick.” This is like one turn of the agent. Similar to how models work, there’s a concept of a “turn”—you give something to the model and get something back. Similarly in trading, in Hummingbot, we have the concept of a tick. 13:00 This is something that’s going to happen in a loop at every defined time interval.

Fede: Yeah, you loop this over and over again. And “what should I do” is basically your strategy.

So what happens when we want to make this agentic? The normal frameworks you’ll see will let you place an order, get data from different sources. But as a structure, they’re usually really unstructured.

What’s the problem with that? First, it’s really difficult to make execution consistent and avoid doing random things on your account—trading with more money than intended, trading with wrong information, or getting stuck in a loop. 14:00

So you want to make it more deterministic. And also have a framework where the agent knows what decisions it can take. It’s not the wild west where it can do whatever it wants.

That’s why we have the concept of executors. This is really good not only for structuring the work, but also because if you expect the agent to place buy and sell orders at mid-frequency, there are executors like the grid where execution is delegated to the executor, and the grid operates at high frequency.

So there’s a good mix you can use with executors. Plus, the other important thing 15:00 is that if you work with executors in our framework, all the actions an agent takes are completely isolated from the actions of your main account or other agents.

So each agent has its own sense of “this is my executor, this is my action.” Executors help us in two ways:

1. Structuring the work and avoiding errors. If you send an order and it starts failing, you probably don’t know why. The agent would start looping trying to understand why it’s failing. An executor has that solved already. For example, if you don’t have balance, it will tell you “insufficient balance”—and that’s standardized for the 40+ connectors we have. 16:00

2. Isolation

Mike: Yeah, I just want to add to what Fede mentioned. The first real advantage is standardization. Hummingbot has connectors to over 50 different exchanges. A connector might be a centralized exchange like Binance, a decentralized exchange like Hyperliquid, or even Solana.

What the executor gives you is: if you say “I want to trade 0.1 Solana and sell it,” you can do that as a market order on Binance or as a swap on Solana, execute the same way, and get the same results.

This standardization allows the agent to not worry about the details of how to call the Binance API versus the Jupiter API on Solana. 17:00 And once you calculate the P&L and everything, the effect of that trade is isolated to this executor. This is what allows you to run lots of different agents with lots of different things and have them act in a standardized way.

Fede: Yeah. So based on all these things, we decided to build what we expect to be the best agent trading framework.

To explain simply: you need to construct the context of the agent—the text you put at the start of the agent before it does anything. Let’s call it the prompt. 18:00

So basically it will be an LLM that will loop. If it needs to call a tool because the response says “call this tool,” it will execute that code, come back to the LLM, and continue looping until it finishes.

The prompt is composed of different things:

1. General system prompt - tells it that it’s a trading agent and needs to do certain actions. This is general for all trading agents, no matter the strategy.

2. Agent.md - the specific strategy or logic the agent will follow

3. Journal - 19:00 a journal the agent keeps for the session, so it knows what it did in the past in that specific trading session

4. Learnings - a higher-level learnings file across different trading sessions

The same agent can be deployed in different trading sessions. You can create a scalper agent and deploy it on this market (that’s a session), then deploy it on another market (that’s another session).

5. Routines available - spoiler: these are just Python files with code that the agent can call, like a script. 20:00 We call them routines because in Condor they can be automated in a loop.

6. Tools available

7. Active executors and positions

So this is basically the prompt. Our trading agent starts with this prompt and works until it decides: should I create something, or should I stop something I have running?

If we look at the file structure, for example this “Agent scalper” has:

• Agent.md - what I was talking about

• Learnings.md - also a top-level file 21:00

• A folder with different routines - like “process candles and add indicators” or “process news”

• A folder with all the trading sessions

Each trading session has:

• Journal.md - where the agent logs everything it’s doing

• A folder with snapshots - where we store the prompt passed to the agent (so you can debug), all the reasoning of the agent, and the actions it took

This is really nice for debugging and understanding what your agent was actually doing.

Mike: Can you explain again—why is Learnings.md at the top level?

Fede: Yeah, that’s a good question. Learnings.md is top-level because it consolidates learnings across all different trading sessions. 22:00

When a trading session ends, or when the agent detects something really important to consider for other sessions, it logs it there—a common error, how to configure something, whatever. It’s a way to have long-term memory for the agent that persists across different trading sessions.

The journal is the specific session memory.

Mike: So the journal is specific to a session, but learnings encapsulates what it learned across different sessions?

Fede: Exactly. It’s to make long-term improvement of the agent down the road.

And then this agent is designed with three run modes, mostly for debugging purposes. 23:00 I don’t want to put an agent to trade without understanding first what reasoning it’s having.

1. Dry run - The agent gets injected into the prompt that it can’t use executor tools to create them. We see how it gathers market data, reasons about it, and what decision it would take. You’ll see in the output “will create this grid,” but since it’s dry run mode, it didn’t actually create it.

2. Run once - Before you put it into a loop, you try it once to see the actual outputs.

3. Loop - The end state when your agent is trading live, 24:00 executing every X amount of time (frequency), like every 60 seconds.

About routines: Python files that usually use the Hummingbot API or an external source in a deterministic way, so the LLM work is reduced.

I’ve been testing this myself and reduced the session from two minutes of reasoning to 50-60 seconds, and I’m planning to improve it even more.

I found that the agent can get candles, but then it was creating Python code to process the candles during the session. 25:00 I said no, I can’t allow this—if Python code can be created by the agent, I should encapsulate it so it can be reused and not spend tokens on it. Moving this into Python files rather than letting the agent process in an unstructured way is a big improvement.

Mike: Oh, I see a question in the chat. Someone asks: why Python and not Rust or C for performance?

First, we’re always constantly improving the framework. There’s a chance we might move certain components into Rust. A lot of the underlying framework from execution and data collection perspective is already in Cython.

But the real reason we use Python for the strategy layer and UI layer is: 26:00 when you’re doing trading, the really expensive activity is at the network layer. When you’re sending a trade to the blockchain or an exchange and getting it back, or when you’re talking to the LLM and waiting for the response to come back.

When building any system, you want to focus on reducing the biggest bottleneck. Whether you use Python or C is not even close to the biggest bottleneck.

But what Fede’s talking about with routines—we actually think that’s the biggest bottleneck. When you design an agent and try it with, let’s say, OpenClaw and Claude directly, you’ll find the agent is wasting a lot of tokens and time processing data and turning it into some indicator or 27:00 post-processed piece of information.

So what Fede is talking about is actually really important—if you spend time upfront to build a structured process to process data, it’s much easier for your AI model to work with the output. That’s also why we call these “routines” and not “skills”—they’re designed to be deterministic and process data in a certain way.

Fede: Yeah, for the agent framework it doesn’t make sense to do it in Rust or C because there’s no expensive computation on that part of the system.

For Hummingbot, as Mike mentioned, the core is in Cython, so it’s quite fast already. 28:00

Personally, I think once you trade a bit—let’s look at Bitcoin one-second candles. When people talk about performance, saying you could be one millisecond faster—tell me what alpha you can get being one millisecond faster for the strategy you want to do.

The only place where speed makes sense is if you’re doing arbitrage or really HFT. You need a very good reason. Looking at one-second candles, if there’s a big move, 29:00 it’s maybe 0.09%—the move we can expect.

Speed is important for arbitrage and such. But there’s a bigger myth about “execution is king.” I think the king is the strategy itself, how you manage risk, how you expose your strategy.

There’s no “if you’re 10 milliseconds slower, you’re going to lose all the money.” That’s completely untrue—bullshit from people saying that on Twitter. For individuals or small firms, strategy, risk management—all that is way more important than speed.

Either way, as Mike mentioned, we’ll always try to improve and have the best system. 30:00 I’m actually doing experiments with a Rust-based system called Hermes. I’ve been running it for a while, building it from the ground up with complete performance monitoring, completely rebuilt the connection system, WebSocket pools, HTTP pools.

We already have latency analysis—we’re under 0.1 milliseconds. We’re under 7.1 milliseconds processing messages. The network latency, as Mike said, is about 200 milliseconds. Obviously I’m in Argentina, so it’s higher than if I deployed in Tokyo.

The interesting thing is the speed we can get with Rust. 31:00 We’ll probably build it and make Hummingbot the fastest framework out there. But for now, we think it’s much more worthwhile to focus on the agent parts.

Also in terms of design—I’m very proud of this—the UI is completely decoupled from the actual engine. All communication between the UI and engine is via socket, so it’s quite fast.

You can add a new source here and suddenly there’s a new subscription in the WebSocket, and you’ll see trades flowing in. So this is the experiment I’m doing to validate how much better we can make it.

Mike: 32:00 Yeah, overall Hummingbot is open source with different modules. The execution and data collection right now is Hummingbot, but that layer can also get better. But we think the most important part to build right now is the agent layer. Having a structure for how you define and build the agent is really important.

Fede: Yeah. Then for the trading session, as I mentioned, you have the journal and the learnings that persist across sessions, and all the MCP tools available.

For creating your trading agent, we’re creating a specific Agent Builder with phases:

1. Strategy design 33:00

2. Market data—what you want to use and how to process it

3. Strategy logic definition—how you’ll use that data to trade

4. Test the agent in dry run

5. Test it in run once

6. Deploy the agent live with looping

Condor Demo and UI Walkthrough

33:00

Fede: It’s time to stop talking and start showing.

I’ll restart this. I hope I don’t break the MCP—I just introduced a change. The repo is the same one we’ve been talking about: Hummingbot Condor. If you star the repo, it helps us a lot.

This is the main entry point right now. 34:00 With this, you’ll be deploying the Hummingbot API that runs on your machine. The Hummingbot API lets you deploy bots, executors, and a lot of things. Once you run make run—I have it here.

Also, if you run make run, I’ve been testing with the QWen model. It’s actually quite good. Soon we’ll add support for open source models, but for now we’re focusing on Claude.

Mike: Yeah, basically I’ll explain the structure of how Condor works. 35:00

If you’re familiar with setting up OpenClaw, you should be pretty familiar with setting up Condor as well. A lot of people use OpenClaw with Telegram. When you use OpenClaw with Telegram, the first thing you do is create a Telegram bot via BotFather.

It’s the same thing with Condor. You go to BotFather in Telegram, it walks you through creating a bot, gives you a token, and you basically just need the token and your user ID.

Once you have those, you enter them into Condor. There’s a setup process that walks you through setting the Hummingbot admin password and the Condor bot token and user ID. After installation, you can start talking to Condor.

Fede: 36:00 Yeah, it’s mostly the same. But there’s a big difference—before creating a trading agent, I’d recommend just playing around with Condor directly.

Let me get my balance sorted first... Okay. You can start talking with Condor directly instead of creating a trading agent. You can say “Hi, what’s my balance on Binance?” 37:00

You’ll need to connect your API keys first. But once you do, it uses the Hummingbot MCP under the hood. It helps you understand your balance on different assets—I can see my perpetual positions as well.

Everything you can do directly with Condor can also execute routines—code that you probably want to run. For example, I can say “What routines do I have to process market data? I’m interested in understanding BTC-FDUSD.”

It will see if it has a routine, or it will just get the candles and analyze the market for you. 38:00 Sometimes there’s a problem getting candles because it’s a lot of data in the context.

Here’s a routine for technical analysis—analyze trend, volatility. It says EMA aligned, fast higher than mid higher than slow. Key support levels, key resistance. Suggestion: grid. I’ll say “Can you deploy a grid executor with 300 FDUSD?”

These routines are really interesting—you can encapsulate market data analysis and trigger it on any market once you’re confident with the analysis. 39:00

For points farming on Hyperliquid, if you want to analyze volatile markets and deploy a grid with a directional bias and farm points while trading, that’s something you can do with Hummingbot right away.

The grid is deployed. Let’s see if it’s true... yeah, it is. This isn’t a normal grid if you’re familiar with Hummingbot—it has parameters like order frequency, max open orders. That’s why you’re not seeing all orders at once. It’s smarter.

As fast as I told it “do this for me,” it was able to connect with everything needed to create the order. 40:00

If you’re not confident about what’s happening with your account or don’t understand the active actions, you can use the /executors command and see active executors—the grid, the volume traded, history.

But if you want a better view, you can use the web view. Run /web command, and it opens a website. This is something you can override in the config if you have a custom DNS, port, or IP address if you’re deploying on a VPS.

Here you have the same dashboard—composition of assets over time, all tokens we have. 41:00 We can see the grid we just deployed, the position holds, and analyze by different controllers.

From the UI itself, you can also deploy grids. Let’s pick Binance, pick SOL-FDUSD. I want to deploy a grid on SOL, put the grid between here, deploy 100 USDT, keep the position, create grid executor. “Grid Executor created.” Now you can see two grids here, and it should be placing orders on SOL too.

So this is the interface we’re working on to make this easily accessible. 42:00 Remember, this is all open source. It’s all free. You don’t need to pay to use it. I think it’s very worthwhile to try.

Mike: Yeah, I just want to say—before we transition to creating a proper agent—a couple of things.

For those of you following Hummingbot, this web interface for Condor is what we think the dashboard replacement will be. A lot of people have asked us to work on the dashboard (the frontend graphical interface for Hummingbot API). What we decided to do was take an AI-first approach. 43:00

We built Condor and made sure it worked in Telegram first. Now this web view is what we’ll focus on building out, making sure it can do both what dashboard can do and also run agents.

Another design choice: you still use Telegram to authenticate. You log into Telegram, create this web view, and the API token you pass in is encrypted with your Telegram credentials. That allows you to access this from anywhere—you can host it on a web server and access it from Telegram without needing to expose admin credentials and have a whole auth system just for the dashboard.

Botcamp Cohort and Competition

43:30

Mike: Oh, also very important before we move on—we’re sponsored by Botcamp, the educational company that Fede and I run that uses the open source Hummingbot framework to teach people market making, algo trading, and how to make it agentic using AI. 44:00

We do two cohorts of Botcamp per year. Each one is a four-week online bootcamp where we teach the principles of market making from a theory perspective and different types of algo trading strategies. We focus on market making because that’s one way to make money doing algo trading, especially in crypto.

For the next cohort, we’re doing something special and new—we’re going to have an AI trading competition at the end. You’ll learn how to create proper agent strategies, learn the theory behind algo trading strategies, then learn how to build them into AI trading agents and run them using Condor.

45:00 The competition is open to both cohort members and previous Botcamp members. They can run their AI agent strategies and compete for prizes from our sponsors. We have about $13,000 already (the website says $10,000, but we just got a new sponsor).

These sponsors are crypto exchanges as well as crypto funds who might be looking to hire participants. There’s a QR code for Botcamp Cohort 13 in the upper right.

The discount code I want to make sure everyone has is: INFOSESH25. You’ll get 25% off. Once again: INFO SESH 25. Check out on Stripe and add it as the promo code. 46:00 It includes three weeks of instruction, help building your own customized AI trading strategy, and entry to the trading competition.

Can you go to the Botcamp website? I want to show people the schedule. Go to cohorts and competitions...

The cohort starts in April—first week starts April 21st. We have four sessions per week. The first four sessions give people a theory and technical perspective on algo trading and how to use Hummingbot to create trading strategies.

47:00 We also do a deeper dive into market making. One reason people use it is because both exchanges and token issuers provide rewards for market making. If you understand how to do it across the crypto landscape, it’s easier to make money because you have this additional source of incentives and value from liquidity rewards.

In the second week, we get deeper into different market making strategies, whether on-chain or off-chain, and how to make strategies more agentic—the different harnesses available, why Condor is structured the way it is versus others like OpenClaw.

48:00 In week three, we get into the agent part—the structure of a trading agent and how to build multiple trading agents (we’re calling them “swarms”) that coordinate with each other. Each one is isolated, acting on its own slice of the portfolio, but also learning from each other.

We also help everyone with office hours. We cap this cohort at 35 participants—I think it’s half-filled right now. We cap it because we try to help everyone build their strategies. The final week is the agent trading competition.

One question from the audience: “I can’t afford the cohort right now, but I’m very interested in the AI trading competition.”

For the future, we’ll open it up and make it public, but since it’s the first time, we want to properly review each one. 49:00 If you’re an existing Botcamp member, there’s a significantly discounted price. We might also create scholarships—you’d earn them by maybe helping us with guests, doing something on Twitter. We want to make room for a couple scholarships for people in the community who can earn them.

Fede: Thank you Mike for the Botcamp presentation. That was quite insightful.

Agent Builder Strategy Walkthrough

49:00

Fede: Now I want to show the last part. I probably won’t deploy live, just show the dry run mode. But I’ll show you a sneak peek of what you can build with Agent Builder. 50:00

First, let me tell Condor what executors are running, then tell it to stop them so we can start fresh.

As you can see, it has all the information we can see in the website. I actually ended up liking the chat interface more than the other one.

For the question about UI—thank you, we finally made it in React as you wanted.

For the question about model support—we’re not supporting only OpenAI. We support Claude, Codex, Gemini, OpenAI, and soon I’ll add Ollama directly. 51:00 With open models now, I think for our bot we can run it with QWen 3.5 at 7 billion parameters. It would be really easy to run. Anyone will be able to run it with private models soon.

But as we want to generate knowledge about how this system works, it’s better to start with the better models so we have a benchmark for what a good agent is.

I’ll say “stop the grids” and it will stop those executors so we stop placing orders. Now we’ll move to the actual Agent Builder.

To go to Agent Builder, you go to /agent, switch the agent mode from “Condor” to “Agent Builder.” It starts a new session. 52:00

Great thing: you don’t need to pay for an API key besides your current subscription because we’re using the MCP protocol that Anthropic released. With your Claude Code subscription or Codex, it will work.

I’ll tell the agent “I want to create a trading strategy” and the Agent Builder will guide me through all the phases.

Phase one: strategy design. What do you want to do? Grid trading, DCA, scalping perps with take profit and stops... Let’s do scalping perps with tight stops.

53:00 It asks what market. Let’s search for something with volatility... this AIOT token has a lot of volatility. Let’s pick this one. What exchange? I want to trade on Binance Perpetual on AIOT-USDT.

Mike: Quick question—when you say “scalping,” can you define what that means?

Fede: Yeah, basically with some trend analysis, we’re going to place long and short trades to try to trade the ups and downs that the market will have.

I’ll say: I want to trade Binance on AIOT-USDT. 54:00 And I want to create a routine that helps me identify where these levels of interest are. I’d like to use one-minute candles and look for support and resistance levels plus EMAs of 7, 25, and 99.

The Agent Builder will understand what I’m trying to do. 55:00 We can specify more things like take profit, but let’s keep it as is for now.

Position size: 25 USDT per trade. Stop loss: 5%. Max concurrent positions: 3. Max drawdown: disabled. Total amount quote: 100 USDT.

Mike: Got it. So the agent will enter long positions when the price is near the support level—when things go up. 56:00

Fede: It would try to go long at the support level, but also the EMAs will probably need to mark an uptrend.

Mike: Okay, there are two indicators it’s using.

Fede: Yeah, it will use the EMAs and also detect support and resistance levels based on the candles.

Now it says “Approve the design and move to phase two” where we’ll build the analysis routine. I’ll create the strategy first to get the ID for the routine, then build the analysis script.

If we go here in PyCharm... you’ll see in the trading agents folder, I have this AIOT Perps Scalper that was created. 57:00 I already have the Agent.md (as you can see, it says “placeholder”—it will be updated in phase three because the Agent Builder is working on it).

So the folder was already created. It added a folder for routines. Here we have the first routine: support_resistance_ema_levels. It created a config file—this is the good thing about having routines. If not, the agent would need to write all this code during runtime.

You can pass the trading pair, connector name, candle count, lookback, tolerance for support/resistance. It wrote all this code to generate the output.

Mike: 58:00 So that’s a new routine it created. But before, in Condor or Telegram, you were also running routines. Are there routines that ship with Condor?

Fede: Yeah, there are general routines that can be shared by all agents, and routines specific to certain agents. That’s something you proposed and I accepted—it’s the right way because it’s simpler to share. I can just share you the Agent folder and you can use it.

So I created the strategy, now let me create the routine. I have a skill for creating routines in the code that explains how to do it.

Here’s the live output—the routine is correct. Let’s see what it’s trying to do. 59:00 The price is correct. The trend says bullish—makes sense because of the EMAs.

The support is marking around 0.33. These are the two supports it identified, and the resistance at 0.36 and 0.37.

Actually, I don’t like the support and resistance levels. I’d like to pick more like 1:00:00 this one for take profit—I’d like it higher.

This is what you can work on. Once the routine runs, you can improve it. It can also generate images and send them through Telegram for processing. You can do everything from the chat, but this is the part you need to work on—it should be doing what you’re expecting.

For the question about backtesting: yes, I was going to work on backtest this week, but I didn’t reach that point—I was working on all this infrastructure. The good thing is that since it follows the same principles as the controllers, it would be easy to backtest. 1:01:00 But I think for backtesting we’ll need local models later on—mostly because it’ll be faster and you won’t waste tokens. Yes, this is on the roadmap to be backtestable.

I’ll say “I like it, but I would like to use the first support for stop loss and the second resistance for take profit.”

That will probably be put into the Agent.md instructions. Then we’ll move to phase three.

Mike: I just want to emphasize again that everything we’re building here is free and open source. We do this because we’re supported by exchanges as partners. 1:02:00

Every time you use Hummingbot for execution, part of the fees you pay does support the nonprofit foundation. But that means we can give away everything we’re building and you can use it.

It’s not end-to-end yet—that’s why backtesting is coming in the future. But right now you can go to GitHub, pull the main branch of Condor, use your Claude Code or whatever model you’ve set up, and start testing this out.

Fede: This is also really interesting—see it says “let me fetch the executor schema first.” 1:03:00

Now it knows what it has to do, what executor it will use. The point is: what’s the schema of the executor? So when I create it, I don’t fail and know how to configure it properly.

If we go to this Agent.md, we see it has the steps: run analysis, decision logic, step three execute the trade, required fields for the executor (take profit and stuff), risk rules, position monitoring, and the journal.

Now it’s suggesting: ready for phase four dry run. I’ll start the agent in dry run mode to analyze the market. 1:04:00

Yes, run it in dry run. As I mentioned, this is one of the modes that lets me simulate what the agent would actually do if invoked for trading.

Now I’ll show you the nicest thing—how we can inspect what the agent is actually doing. This is one of the most important parts: observability.

If you go to the Condor Dashboard, you’ll see a tab for Agents. In this Agent tab, we can see the AIOT Perps Scalper. We have the default total amount quote, frequency in seconds, the mode, risk settings, and the strategy 1:05:00 (the markdown file we saw—you can edit it from here and save it if you’re not at the computer).

You have the learnings file that persists across all sessions. We’ll have sessions here—once the agent is looping, they’ll appear here.

We have this dry run—the first output. The agent says: Run decision: no entry. EMAs not aligned. Failed the directional filter. The agent identified mixed trend and waited for the strategy rules. No position opened.

Here in the UI, we can see the Agent response: price, trend is mixed, the EMA values, support and resistance found, decision: wait. 1:06:00 No executors created (dry run). We can tell it to run again.

Mike: Just so I understand—that table, did that come from the routine it ran?

Fede: This Agent response is actually coming from the actual agent—the output of the final agent. We’re not seeing the output of the routine in the tool calls here. But we’ll probably add the ability to expand and see it.

We have now the second dry run: no executors, decision wait, trend mixed. Perfect. Now we’re okay with this. We like it.

Live Trading Observability and Wrap

1:07:00

Fede: It’s time to deploy live on a loop.

The agent is being disciplined, waiting for a clean setup. The market is ranging. I’ll say “I’m ready for phase five. Let’s go live with a frequency of one minute between executions.”

Condor monitoring commands: check the agent, show the journal. The agent is scanning every minute.

If it worked—we just see here the session. Now we have the first session. 1:08:00 If we go to sessions, we have the first session appearing here.

This is what I talked about—trading sessions. Each session has activity, snapshots. In the snapshots, we can see the actual data, the system prompt (all the data injected into the agent), the actual agent response, and the tool calls.

This will execute every minute now. Seems like the trend... I think we need to wait until this EMA line passes the other one—that will be looking for a long position.

Someone in chat mentions Memento is working on a market simulator for Hummingbot. Nice, I don’t know what that actually is, but nice.

Mike: 1:09:00 Yeah, overall Hummingbot is an open source framework. It’s modular—there’s the core Hummingbot client, the API which this uses, and Condor itself (the harness) is also open source.

What that allows people in the community to do is build off of Hummingbot. Many organizations build their own connectors. Memento is building some type of backtester or simulator. We encourage this, and that’s why we’re making the trading agent standard open source—so you can build your own agents according to the standard.

We’ll have a place where you can share your agents with each other, and also the routines used by these agents.

One question: when you did the dry run, were those also sessions but not live? 1:10:00

Fede: No, it’s not a session. It’s just an execution of one tick without the agent being able to trade. You can see no executors were created—executor creation is blocked.

Mike: Okay, so it’s run once but with no execution.

Fede: Exactly.

So as you can see, we already have two ticks. It’s probably processing the last tick and hopefully... oh, it created the first order! Guys, see this—and it already has take profit set. So this is our first agent trade live. Hope we reach the take profit.

If we go here, we should see the last snapshot. 1:11:00 Snapshot three: trend flip bullish, check lock, long conditions bullish. Nice. Price within 2% for S1 ratio. All conditions met, opening long. Journaling entry. And as you can see here, we have the take profit.

Mike: Yeah, nice! First agent trade placed on The Bot Pod by an agent. I added some graphics for that.

But yeah, I noticed you had other trades on your Binance account other than AIOT—I think you had some MEME trade going on.

Fede: Yeah, that’s another one I’m holding from yesterday. It’s a long position created with a grid executor that I decided to hold. As you can see, it’s “position hold” now.

Mike: I just want to highlight—this agent is isolated, right? Can you explain how it works? 1:12:00

Fede: Yeah... let me see... ah, it hit the stop loss. So maybe the stop loss was very tight. Let me see the config... stop loss: he put like 0.45%. It’s very low. That’s part of what the agent should be improving.

Seems like it hit the stop loss. How is it isolated? As you can see here, I can see “main” and I can see all the grids I created. This one is the MEME one I decided to hold. And I have here the AIOT Perps Scalper—that’s the one the agent is running now.

Because of the design of executors, each executor has an owner that you specify when you create it. So each agent has knowledge about which executors it created. 1:13:00

It has a virtual portfolio and virtual executors. In that sense, all activity is completely isolated—that’s why this can scale. We can have 10 agents running in parallel without them having trouble understanding what actions each agent took.

Mike: Can you go to the perps agent? Can you see what it said in the last session? I think that’s when it hit the stop loss.

Fede: Yeah. “No entry conditions, wait. Trend reverted to mixed. Barely below. No directional conditions.”

Mike: Got it. So 1:14:00 the agent created an executor—and actually, an executor is like a trade but with take profit and stop loss built in, placing additional orders besides the first one.

So it hit the stop loss and now it’s back in the null state, just waiting for a signal to create an executor.

Fede: Yeah. And also it’s understanding that it had a loss here.

So probably in the next one we’ll increase the stop loss a bit, or not—I don’t know. It’s interesting. It’s part of the learnings we need to do with this system.

Mike: So the agent is capable of modifying the stop loss or signals based on learnings?

Fede: Yeah, obviously. That’s the purpose of learning. 1:15:00 And you can also inject information into the learnings. Here, I can write something—it doesn’t know I was writing it.

Mike: Okay. When are learnings injected? Every tick?

Fede: Yeah, on every tick you inject the learnings. As I mentioned in the diagram, the prompt will have the general agent specification, the journal, the learnings, the routines available, the tools available, and the active executors.

Mike: Okay.

Fede: I think that was a very good session. I hope people get excited about this.

Mike: Yeah! So we’ll be doing this next week again.

We’ll continue scheduling livestreams at 9am Pacific / 12pm Eastern. For those in South America, it’s late afternoon. In Europe and Asia, late evening.

We’ll try to do the same time every Friday. We’re currently streaming on Twitch, YouTube, and Twitter. 1:16:00 We’ll also try to publish this format on other platforms.

What you can expect is every week we’ll demo something we’re building at Hummingbot. And because everything is open source, you can go try it yourself. We encourage you to work on Hummingbot, build whatever you want.

If you have questions, you can always join our Discord and ask us directly.

Once again, we’re hosting another cohort of our Botcamp bootcamp for market makers and algo traders, starting April 21st. If you use the code INFOSESH25, you’ll get 25% off the Cohort 13 price.

This is Mike and Fede—we’re the maintainers of Hummingbot. Our mission is to democratize trading using open source.

Fede: Alright.

Mike: Okay, bye. 1:17:00

Fede: Bye!

Dear Hummingbot community,

This month marks a pivotal moment in Hummingbot’s evolution. With v2.13, we’re not just shipping another release — we’re laying the foundation for Condor, our upcoming open-source operating system for managing crypto trading agents.

Condor represents our vision for the future of algorithmic trading: a specialized harness purpose-built for crypto trading agents, powered by the Hummingbot open source infrastructure and global trader community. General-purpose harnesses like OpenClaw and Claude Code can already run Hummingbot effectively, but Condor is laser-focused on what traders actually need: AI agents running professional grade strategies with reliable execution across any exchange and blockchain, controllable across mobile and desktop with Telegram.

The v2.13 release builds the critical infrastructure that Condor will leverage: Hummingbot MCP server and Skills, direct executor management via API (no more spinning up Docker containers for each strategy), automated DEX LP strategies, and new exchange partners like Aevo, Backpack, and Pacifica that extend Hummingbot’s capabablities to more venues. Soon, you’ll be able to combine AI intelligence with Hummingbot’s execution layer to build machines that make money for you 24/7.

Condor is coming.

Michael Feng
Co-founder, Hummingbot

🚀 What’s in the Hummingbot v2.13 Release

🔗 New Connectors

This release adds support for three new exchanges:

• Aevo - Options and perpetuals DEX on Ethereum L2

• Backpack (Spot & Perpetual) - Solana-based exchange with spot and derivatives trading

• Pacifica Finance - DeFi trading platform

✨ New Strategies

• LP Executor and Controller - Deploy automated liquidity provision strategies on concentrated liquidity DEXs through simple API calls (executor) or long-running Docker container (controller)

• PMM V1 - New V2 controller that faithfully replicates the original pure market making V1 strategy

• PMM Mister: An advanced version of the original PMM strategy with sophisticated risk management and inventory management

✨ New Features

• Executor support in Hummingbot API: Now, you can deploy executors directly without spinning up new Docker containers

• Binance TRADIFI_PERPETUAL support - Trade tokenized equities and RWAs on Binance perpetuals

• Upgraded Binance user stream - Improved WebSocket connection handling for real-time updates

• Improved Orca connector - On-chain data for accurate CLMM position pricing, accurate position rent tracking, and support for Token2022 tokens

  v2.13 Release Notes

🤖 Hummingbot MCP Server and Skills

We’ve open-sourced two powerful Github repositories that let you give your AI agents access to Hummingbot’s trading infrastructure: the MCP Server and Skills.

💻 Hummingbot MCP Server

The Model Context Protocol (MCP) server enables AI agents running in Claude Code, Gemini CLI, and other MCP-compatible environments to interact directly with Hummingbot for automated cryptocurrency trading. It acts as a bridge between your AI agent and Hummingbot’s execution layer, providing the context

Key capabilities:

• Account & connector management - Configure exchange credentials and API keys

• Portfolio queries - Check balances across all connected exchanges

• Real-time market data - Access live prices, order books, and candles

• Executor and controller deployment - Deploy trading strategies as simple executors or long-lasting controllers

💻 Hummingbot Skills

Skills are installable AI agent capabilities that extend what your agent can do with Hummingbot. Install them with a single command:

npx skills add hummingbot/skills

Popular skills include:

• hummingbot-deploy - Deploy Hummingbot infrastructure (API server, MCP server, Telegram bot)

• lp-agent - Automated liquidity provision on CLMM DEXs like Meteora and Raydium

• find-arbitrage-opps - Scan for cross-exchange arbitrage opportunities

• find-xemm-opps - Identify cross-exchange market-making opportunities

Together, the MCP server and Skills allow users to give Hummingbot’s strategies and 50+ exchange connectors to AI agents running in Claude Code, OpenClaw, and other agentic operating systems. Condor will leverage both repos under the hood—delivering a trading-focused UX optimized for the workflows that matter most to algorithmic traders.

👉 Direct Executor Creation via API

One of the most important features for trading agents is deterministic execution - the ability to automate trading workflows like stop losses, automatic position management, and arbitrage. That’s why we created Executors in the V2 framework.

Now with the v2.13 release, Hummingbot API can create and manage executors directly without the overhead of Docker containers:

• Direct executor deployment - Create, monitor, and stop executors through simple API calls without spinning up separate Docker instances

• Per-executor logging - Each executor now maintains its own log buffer with error tracking, accessible via GET /executors/{executor_id}/logs

• Orphan cleanup - Executors stuck in RUNNING status after crashes are automatically cleaned up on startup

• Consolidated deployment path - All bot deployment now uses the unified controller-based architecture

This means AI agents can now programmatically deploy trading strategies, monitor their performance in real-time, and make adjustments—all through a clean REST API. It’s the foundation that enables Condor to orchestrate multiple trading strategies simultaneously.

See the implementation details in PR #114 and PR #128.

LP Strategies in Hummingbot and Hummingbot API

If you’re a sophisticated market maker (or memecoin degen trader like me), you know that concentrated liquidity provision on DEXs like Meteora and Orca requires constant position management — exactly the kind of task that AI agents excel at. V2.13 introduces supports for automated LP strategies in both the legacy Hummingbot client as well as Hummingbot API.

New Capabilities:

• LP Position Executor - Automated management of concentrated liquidity positions on CLMM DEXs

• LP Rebalancer Controller - Orchestrates position rebalancing based on configurable triggers

• State machine management - Handles the full lifecycle from position opening through rebalancing to closure

• Performance tracking - New lphistory command for analyzing LP strategy performance

The LP Executor integrates directly with the Hummingbot API, allowing AI agents to:

1. Open liquidity positions with specified price ranges

2. Monitor position health and impermanent loss

3. Automatically rebalance when positions drift out of range

4. Close positions and recover fees

This is a prime example of how Condor will leverage Hummingbot — the AI agent makes strategic decisions about when and how to provide liquidity, while Hummingbot handles the complex on-chain execution reliably and deterministically.

See PR #120 (API support) and PR #8082 (core LP executor).

New Connectors: Pacifica, Aevo, and Backpack

V2.13 expands our exchange coverage with three new connectors, approved through Hummingbot governance:

• Backpack: CEX with spot and perpetual futures trading featuring native Backpack Solana wallet integration

• Pacifica: Solana-based perpetual futures DEX

• Aevo: Ethereum L2-based perpetual futures and options DEX

Each connector follows our standard architecture, meaning they offer standardized WebSocket/REST endpoints for market data and execution, and they work seamlessly with Strategy V2 executors and the Hummingbot API. Condor users will be able to deploy agents across all three exchanges from day one.

See the full v2.13 release notes for technical details.

Botcamp Cohort 13: AI Trading Agents

Dates: April 14 - May 15, 2026

We’re launching Cohort 13 on a completely redesigned platform that houses all Botcamp courses, cohorts, and strategies in one place. The curriculum has been revamped to incorporate AI-assisted trading workflows throughout.

What’s New:

• AI Trading Agents module - Learn to build trading agents using Hummingbot’s MCP server and Claude Code skills

• Revamped schedule - Four weeks of progressive learning with live sessions at 8am PST / 3pm UTC

• 48-hour trading competition - Demo Day now launches a live trading competition with results announced 48 hours later

• Lifetime platform access - 20+ hours of recordings and four premium courses ($800 value)

Preview the new platform and full schedule at dev.botcamp.xyz/cohorts/cohort13.

Security Notice

Beware of scammers impersonating the Hummingbot Foundation:

• We NEVER DM you first

• We NEVER sell or airdrop HBOT tokens

• HBOT is only earned through completing bounties

• Report suspicious activity in our Discord #scam-reports channel

Hummingbot v2.12: From CLI to API

Dear Hummingbot community,

With the release of Hummingbot v2.12, we’re close to completing a major architectural shift that has been years in the making: transitioning Hummingbot from a monolithic, single-purpose CLI to an institutional-grade algorithmic trading API with connectors to every CEX and DEX, accessible securely from anywhere. All open source, all completely free!

In this release, we decoupled order book management in the Hummingbot core client. Previously, Hummingbot initialized order books for all configured trading pairs at startup. Now, order books are loaded on-demand when actually needed. This change lets Hummingbot API deploy executors directly, which means that you can now run bots through simple API calls instead of having to start and stop Docker containers.

The next phase? Making this power accessible through Condor (consider join our new focus group - see below), and deeper integration with Hummingbot MCP so that you can use AI to control your trading infrastructure.

Michael Feng
Co-founder, Hummingbot

v2.12 Release Notes

🚀 Hummingbot API Quickstart

We’ve streamlined the installation process so you can deploy your own private algorithmic trading server with a single command:

curl -fsSL https://raw.githubusercontent.com/hummingbot/deploy/main/setup.sh | bash

This one-line installer sets up Hummingbot API along with Condor, our Telegram bot interface. Within minutes, you’ll have a trading server that you can control from your phone—completely free and open source.

Follow the new quickstart guide below.

Hummingbot API Quickstart

📊 Core Enhancements: Dynamic Order Books

This release introduces dynamic order book initialization, a major architectural change that decouples order book management from the Hummingbot core client.

Previously, Hummingbot initialized order books for all configured trading pairs at startup. Now, order books are loaded on-demand when actually needed. This change means that the Hummingbot API can now launch executors directly—without starting a full bot instance.

Hummingbot API’s new ExecutorService can deploy Position, Grid, DCA, TWAP, and Arbitrage executors independently, managing their own market data feeds and order tracking. No Docker containers, no strategy configuration files—just API calls.

We will build upon this functionality in upcoming releases.

💧 Hyperliquid HIP-3 Markets

With the v2.12 release, Hummingbot now fully supports HIP-3 markets on Hyperliquid, enabling access to markets for equity and RWA perps on Hyperliquid.

• Full HIP-3 integration with unique trading pair format support

• Complete candlestick and order book data feeds

• Rate source integration for accurate mid-price calculations

To find HIP-3 pairs, enter the issuer prefix and the pair, separated by a colon, like XYZ:TSLA-USD.

📱 Condor Focus Group

We’re starting a focus group for users interested in providing feedback on Condor, our new Telegram interface to Hummingbot API. We’re seeking users from a variety of backgrounds and trading experience levels.

If you’d like to participate and help shape the future of mobile trading with Hummingbot, reach out to a member of the Foundation team on Discord or reply to this email.

👿 Security Reminder

Stay vigilant against scammers:

• We never DM users first

• We never sell or airdrop HBOT tokens

• The only way to get HBOT is by completing bounties

• Report suspicious activity in our #scam-reports Discord channel

Happy trading! 🤖

Hummingbot v2.11: Control Your Bots from Anywhere

GM to all the Hummingbot users around the world 🌎

Hummingbot v2.11 introduces Condor, a brand-new Telegram-based UI that lets you execute trades and control your trading bots from anywhere — both phone and desktop. Combined with the new Orca DEX connector and HyperLiquid API key support, this release makes Hummingbot more accessible and powerful than ever.

As we wrap up 2025, I’m incredibly proud of how far Hummingbot has come. It’s been almost 7 years since the first Github release and 4 years since the Hummingbot Foundation was established. In next Tuesday’s monthly community call, I’ll recap the Hummingbot journey, explain how it has become a self-sustainable open source project, and proposed a simplification to the Hummingbot Foundation governance system that should make it easier to utilize by the entire global community, from traders to developers to exchanges.

Michael Feng
Co-founder, Hummingbot

v2.11 Release Notes

📲 Introducing Condor — the Telegram-based companion to Hummingbot API

Condor is a new Telegram-based control center for Hummingbot, giving traders a fast and intuitive way to monitor bots, execute trades, manage liquidity, and interact with Gateway — all directly from their phone.

Built on the Hummingbot API, Condor provides a streamlined interface for both CEX and DEX operations, offering real-time dashboards, interactive menus, and a unified configuration system.

Key Features:

• 📊 Portfolio: View your real-time P&L across all your CEX and DEX positions

• 🤖 Bot Management: Configure, deploy, and monitor multiple Hummingbot instances

• 🔁 CEX & DEX Trading: Execute trades on any spot CEX, perp DEX, and AMM DEX

• 💧 Liquidity Management: Browse pools, open LP positions, and harvest fees

• ⚙️ Multiple Servers: Manage multiple Hummingbot API servers

Condor makes Hummingbot more accessible than ever — perfect for traders running bots across multiple environments who want lightweight, remote monitoring and execution without needing a desktop terminal.

🚀 Get Started: Watch Friday’s livestream below where our CTO Fede will show how to set up Condor alongside Hummingbot API.

Alternatively follow the new Hummingbot API Quickstart Guide which includes Condor setup.

🐳 New Orca Connector for Solana DEX Trading

Hummingbot v2.11 also introduces a brand-new Orca connector, bringing one of Solana’s most trusted DEXs into the Hummingbot ecosystem. This integration enables traders to execute swaps and manage concentrated liquidity positions using standardized endpoints in Hummingbot Gateway.

This connector was developed through our connector bounties program, in which Hummingbot Foundation works with exchanges to fund high-quality integrations built by experience Hummingbot community developers.

Orca Connector Docs

📅 Join Our December Community Call - Next Tuesday!

Save the date for Tuesday, December 17 — this month’s community call will be a special one!

At 7am PST / 11am EST / 11pm Singapore time, join us on Discord in the #community-video-calls channel.

This month, I’ll be covering:

🚀 The Hummingbot Journey: How Hummingbot has evolved into a self-sustainable open source project powered by community usage across the exchange landscape

🏛️ Governance Simplification: A proposed simplification to the Hummingbot Foundation governance system that should make it easier to utilize by the entire global community — from traders to developers to exchanges

🛣️ Technical Roadmap: A preview of what’s ahead for the Hummingbot ecosystem in 2026

Join on Discord to get your questions answered, or watch the recording, which will be published on YouTube afterwards.

Join Discord Event

👿 Security Reminder

Stay vigilant against scammers:

• We never DM users first

• We never sell or airdrop HBOT tokens

• The only way to get HBOT is by completing bounties

• Report suspicious activity in our #scam-reports Discord channel

Happy trading! 🤖

Hummingbot v2.10: AI-Powered Trading Bots

GM to all the 🤖 Hummingbot traders and developers around the 🌎 globe!

This release integrates Gateway into Hummingbot API, adding DEX trading and liquidity provision to its already-extensive capabilities. We’ve also significantly improved Hummingbot MCP, making it easier for you to control local or remote API servers using Claude, ChatGPT and other AI assistants.

As someone who tries to spend his life outdoors in nature, I’ve always dreamed of being able to control my trading bots and react to changing market conditions from the extreme wilderness. With the Hummingbot v2.10 release (and other technologies like Starlink), that vision is closer to reality than ever!

Michael Feng
Co-founder, Hummingbot

See v.2.10 Release Notes

🤖 Building AI-Powered Trading Agents with Claude Code & Hummingbot

Watch our CTO Federico show how to use AI to execute trades, create LP positions, and deploy automate strategies across CEX and DEX:

✨ Install and configure Hummingbot API + MCP Server

🧠 Connect Claude Code, Gemini, ChatGPT, and other AI assistants

🔄 Execute trades on Solana and deploy Meteora LP ranges with natural language

🌐 Manage both CEX and DEX operations through AI

Get Started: Follow our updated Hummingbot MCP documentation to connect your AI assistant in minutes!

🔗 Gateway × Hummingbot API Integration

We’ve integrated Gateway directly with the Hummingbot API, creating a single control plane for both centralized and decentralized exchange operations.

Now you can manage CEX/DEX trading and liquidity provision through one unified interface, store all the trades and positions you create, and control everything with AI!

📚 Install Hummingbot API and start running a powerful CEX/DEX trading command center!

🔄 Updated Bitget Connectors

We’ve introduced a new Bitget Spot connector and completely refactored the Perpetual connector to align with Bitget’s latest API specifications, strengthening our partnership with Bitget. See this link for the announcement, and look forward to co-marketing campaigns announced in the Hummingbot Discord and Twitter soon!

✨ New Spot Connector: Full integration for Bitget Spot trading

🔄 Perpetual Refactor: Migrated to newest API endpoints for improved reliability

📊 Candles Feed Support: Added candle feeds for both Spot and Perpetual markets

See 📚 Bitget Connector for more info!

🥞 PancakeSwap Solana CLMM Connector

This release introduces a new Gateway DEX connector: PancakeSwap Solana, bringing professional market making tools to Solana’s fastest-growing DEX.

💧 Full CLMM Support: Open/close positions, add/remove liquidity, and collect fees on PancakeSwap Solana V3 pools

⚡ Native Solana Integration: Built on Solana’s high-performance blockchain infrastructure

See 📚 Pancakeswap Connector for more info!

📅 Join our November Community Call Tomorrow

Save the date for Wednesday, November 5!

At 7am PST / 11am EST / 11pm Singapore time, join our monthly community call on Discord in the #community-video-calls channel.

Perfect for community members and developers interested in:

• Technical roadmap updates

• Dev bounty opportunities

• Architecture deep-dives

• Strategy framework discussions

The recording will be published on YouTube afterwards.

👿 Security Reminder

Stay vigilant against scammers:

• We never DM users first

• We never sell or airdrop HBOT tokens

• The only way to get HBOT is by completing bounties

• Report suspicious activity in our #scam-reports Discord channel

Happy trading! 🤖

Hummingbot v2.9.0 is Here!

GM to all the 🤖 Hummingbot traders and developers around the 🌎 globe!

We’re excited to announce the release of Hummingbot v2.9.0, featuring a revamped Quants Lab for research and data collection, return of the PancakeSwap connector, and powerful RPC provider integrations:

🧪 Revamped Quants Lab for Trading R&D

We’ve completely overhauled the Quants Lab repository, transforming it into a comprehensive platform for quantitative trading research:

📊 Data Collection & Processing: Collect and process market data from multiple sources for systematic analysis

🔬 Strategy Development: Build custom screeners, develop trading strategies, and backtest using the Hummingbot Python library

⏰ Task Orchestration: Automate scheduled execution of Jupyter notebooks and custom tasks

📱 Multi-Channel Notifications: Schedule automated reports via email, Telegram, Slack, and Discord

📚 Quick Start Notebooks: New research notebooks to help you get started faster

🥞 PancakeSwap Returns to Gateway

The PancakeSwap connector has been updated for the modernized Gateway architecture! Trade and provide liquidity on BNB Chain’s largest DEX and its instances other EVM chains:

✨ Router: Swap using optimal trade routing across all PancakeSwap pools

💧 AMM + CLMM: Swap and add liquidity to individual V2 and V3 pools

🌐 Multi-Chain: BNB Chain, Ethereum, Arbitrum, Base, Polygon, and zkSync

⚡ RPC Provider Abstraction System

The Gateway DEX middleware now features a flexible RPC provider system for optimized blockchain connectivity, along with dedicated integrations to Helius and Infura.

🌟 Helius Integration: Leading Solana validator with WebSocket RPC, regional endpoints, and Jito support

🔷 Infura Integration: Enhanced reliability across 8+ EVM networks with automatic endpoint resolution

🔧 Easy Configuration: Simple gateway config <provider> update commands to add API keys

See Release Notes

🤖 Master Hummingbot MCP + API Server

Learn how to supercharge your trading with AI assistants! We’ve created a comprehensive tutorial playlist showing how to install the Hummingbot MCP and using it to control the Hummingbot API server with AI:

📺 Watch the Tutorial Playlist:

What You’ll Learn:

• Set up MCP server with Hummingbot API

• Connect Claude, Gemini, and other LLMs to control your bots

• Execute trades and deploy strategies through conversational interfaces

💧 XRPLiquid Reaches $25M Volume Milestone

Exciting news from the XRPLiquid market maker rewards platform! The community has achieved an impressive milestone with over $25 million in volume and 623,000+ rewarded orders.

🏆 Season 1 Reward Pool: Join the inaugural season and compete for your share of $100,000 in total rewards

💰 Weekly Rewards: Earn 400 XRP per week through trading in eligible XRPL pairs

📈 Track Your Progress: Climb the leaderboard and earn weekly XRP reward checks

How to Run Hummingbot on XRP Ledger

📅 October Community Call

Save the date for Wednesday, October 8!

At 8am PST / 11am EST / 11pm Singapore time, join our monthly community call on Discord in the #community-video-calls channel.

Perfect for community members and developers interested in:

• Technical roadmap updates

• Dev bounty opportunities

• Architecture deep-dives

• Strategy framework discussions

Recording will be published on YouTube afterwards.

👿 Security Reminder

Stay vigilant against scammers:

• We never DM users first

• We never sell or airdrop HBOT tokens

• The only way to get HBOT is by completing bounties

• Report suspicious activity in our #scam-reports Discord channel

Happy trading! 🤖

🚀 Hummingbot v2.8.0 is Here!

GM to all the 🤖 Hummingbot users around the 🌎 globe!

We're thrilled to announce the release of Hummingbot v2.8.0, featuring newly refactored Gateway DEX middleware and groundbreaking AI integration capabilities:

🔗 Gateway 2.8.0 - Major Architecture Refactor

This release completes the Gateway refactor approved by the community in NCP-22 and introduces a completely revamped architecture that transforms how you interact with DEXs:

⚡ Modernized DEX Infrastructure: Standardized schemas across all connectors with native Gateway commands directly in Hummingbot

🔄 Updated Connectors: Fresh implementations for Uniswap, Raydium, Meteora, and Jupiter with improved performance and reliability

💰 Active Bounties: Help upgrade PancakeSwap, Curve and other legacy connectors - bounties now open!

🎛️ New Trading Commands: Execute swaps and manage LP positions directly from the Hummingbot CLI

>>> gateway swap jupiter/router SOL-USDC BUY 0.01

Fetching swap quote for SOL-USDC from jupiter/router... 

=== Swap Transaction ===
Token In: SOL (EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v)
Token Out: USDC (So11111111111111111111111111111111111111112)
Price: 186.61700000000002 USDC/SOL
Slippage: 1%
Price Impact: 0.00%

Do you want to execute this swap? (y/n) >>>

🔐 Hardware Wallet Support: Enhanced security with Ledger integration

✅ Full Compatibility: Works seamlessly with existing scripts and strategies - no migration needed

See release notes

🤖 Hummingbot MCP Server

We're introducing the Hummingbot MCP (Model Context Protocol) Server - a game-changing module that connects Hummingbot API with AI agents, automation frameworks, and external tools via the MCP standard.

This opens up entirely new possibilities for algorithmic trading:

• Control Hummingbot through Claude, Gemini, and other LLMs

• Build AI-powered trading workflows

• Create custom automation with natural language commands

• Deploy and manage bots through conversational interfaces

🎥 Hummingbot Live: Using AI for Trading

Join us Friday, August 22 for a special livestream showcasing the new MCP capabilities:

📅 When: Friday, August 22
🔗 Where: youtube.com/live/Tvun-Zn-ii0

Agenda:

• ⛓️‍💥 Hummingbot MCP + API: What is a MCP server and why should you use it with Hummingbot API?

• 🤖 MCP Demo: Use Claude, Gemini, and other LLMs to execute trades and deploy bots on any Hummingbot exchange

• ❓ Live Q&A: We'll answer all your questions!

📅 August Community Call

Tuesday, August 27 - Join our monthly community call on Discord in the #community-video-calls channel.

Perfect for community members and developers interested in:

• Technical roadmap updates

• Dev bounty opportunities

• Gateway architecture deep-dives

• V2 Framework discussions

Recording will be published on YouTube afterwards.

🎓 Botcamp Cohort 12 Info Session

Right after the Community Call on August 27, we'll host a special info session about Botcamp Cohort 12:

📺 Watch Live: youtube.com/live/KCFZsTuOsm4

What We'll Cover:

• 🎓 What You'll Learn: Deep dive into the skills and strategies that will empower you

• 🗓️ The Full Cohort Schedule: Plan your 4-week journey to level up your trading prowess

• ✨ What's NEW in Cohort 12: Discover the latest features and upgrades to the program!

🚀 Botcamp Cohort 12 Starting September 9

The next cohort of our intensive algorithmic trading bootcamp is just around the corner!

Program Details:

• Start Date: September 9, 2025

• Duration: 4-week intensive program

• Format: 12+ live online sessions with lifetime recording access

• Instructors: Direct teaching from Hummingbot co-founders

• Certification: Official certification upon completion

• Demo Day: Present your strategy to the community

📚 Full Schedule: botcamp.xyz/cohorts

Don't miss this opportunity to master the V2 Framework, Hummingbot API, and now the new MCP Server capabilities!

👿 Security Reminder

Stay vigilant against scammers:

• We never DM users first

• We never sell or airdrop HBOT tokens

• The only way to get HBOT is by completing bounties

• Report suspicious activity in our #scam-reports Discord channel

Happy trading! 🤖

🚀 Hummingbot v2.7.0 is Here!

GM to all the 🤖 Hummingbot users around the 🌎 globe!

We're excited to announce the release of Hummingbot v2.7.0, featuring major architectural improvements and new capabilities:

🔌 Hummingbot API (formerly backend-api)

The biggest update in v2.7.0 is the complete revamp of our API infrastructure. The backend-api has been renamed to hummingbot-api with significant improvements:

• ⚙️ Production-Ready Architecture: Standardized API for managing bots, executing trades, and monitoring multi-exchange portfolios

• 🔄 Expanded Trading Capabilities: Direct trading, portfolio rebalancing, and account management—all via API

• 🤖 AI-Ready Design: Built for agentic trading workflows and seamless integration with LLMs like Claude

• 📊 Comprehensive Bot Orchestration: Deploy and manage multiple trading instances through a unified interface

• 🧰 Modern Python Client: Asynchronous API client available on PyPI for easy integration

The new architecture uses FastAPI server, PostgreSQL database, and EMQX message broker to provide a robust foundation for building custom trading applications, dashboards, and AI-powered trading workflows.

🧠 Headless Mode

Run Hummingbot without the graphical interface, reducing memory usage by up to 40%. Perfect for VPS deployments and resource-constrained environments:

./bin/hummingbot_quickstart --headless -p PASSWORD -f STRATEGY_CONFIG_FILE

🔧 Enhanced Stability

• XRPL Connector Fixes: Resolved memory leak issues in WebSocket connections

• Memory Optimization: Improved cleanup of asynchronous tasks across the codebase

• Gateway Improvements: Better error handling and gas management for Uniswap and Jupiter connectors

  See Release Notes

💦 XRPLiquid Crosses $4M During Beta

XRPLiquid, a third-party rewards program operated by Botcamp Inc., has crossed $4M in total volume with 1,250 XRP distributed to market makers across 6 active trading pairs.

🎥 Watch the launch presentation at XRPL Apex:

The current pool is 200 XRP shared among participating market makers each week, and will increase after the beta program ends.

Now, you can earn rewards in all 6 available markets via AMM trading using the XRPLiquid app, or by connecting your Hummingbot to XRPL for automated market making.

Register with your XRPL wallet and start earning at xrpliquid.com!

🎓 Botcamp Cohort 12 Starting Soon

Botcamp Cohort 12 is launching in September! This intensive 4-week program teaches you to build algorithmic trading strategies using Hummingbot's V2 Framework and the new Hummingbot API!

Program Highlights:

• Duration: 4-week intensive bootcamp starting September 9, 2025

• Format: 12+ live online sessions with lifetime recording access

• Instruction: Direct teaching from Hummingbot co-founders Mike & Fede

• Certification: Official certification upon completion

• Demo Day: Present your strategy to the community

⏰ Early Bird Pricing Ends August 1

Secure your spot at the early bird rate before the deadline. Limited spots available!

🔗 Learn more and register: botcamp.xyz/cohorts

🎥 Hummingbot Live: Gateway Series

Our Gateway series showcases ongoing development work for the upcoming v2.8 release, with technical deep-dives into new architecture and capabilities:

Recent Episodes and Upcoming Streams:

• Published: Gateway v2.8 Installation and Setup

• Livestreaming July 18: Gateway v2.8 Architecture Overview - Introduction to the standardized API design

• Livestreaming July 25: Managing LP Positions with Gateway v2.8 - Upcoming episode on liquidity management features

These sessions provide insights into active development work and upcoming improvements to Gateway's DEX integration capabilities. Each episode covers work-in-progress features that will be included in the v2.8 release in August.

👿 Security Reminder

We've noticed increased scammer activity, particularly around fake HBOT token sales. Please remember:

• We never DM users first

• We never sell or airdrop HBOT tokens

• The only way to get HBOT is by completing bounties

• Report suspicious activity in our #scam-reports Discord channel

Happy trading! 🤖

Thanks for reading the Hummingbot Newsletter! Subscribe for free to get notified of each monthly release.