Five AI Agents on One GPU: What Building FinAgent Taught Me / Nov 20, 2026

7 min readBy Emmanuel Akinfulubi
Five AI Agents on One GPU: What Building FinAgent Taught Me

FinAgent is a hackathon project. Its signals are not financial advice, and nothing in this post is a recommendation to trade. The code is public at github.com/emmanuelakbi/FinAgent.

In May 2026 I built FinAgent for an AMD developer hackathon. You give it a watchlist of tickers, and it produces a BUY, SELL or HOLD signal for each one, with an entry price, a stop-loss and a target.

The interesting part isn't the trading. It's the constraints. Five CrewAI agents share one self-hosted open model, Qwen3-14B, served by vLLM on a single AMD Instinct MI300X. There are no paid model APIs. The $100 AMD Developer Cloud credit was the whole compute budget.

Here is how it fits together, and what I'd take into any agent system, trading or not.

Five small jobs instead of one big prompt

The first version of any agent idea is usually one long prompt: "analyse this stock and tell me what to do". It's hard to test, and when the answer is wrong you can't tell which part of the reasoning failed.

FinAgent splits the work into five roles:

AgentJobWaits for
Market ScannerA first look at the ticker and its marketNothing, runs in parallel
Fundamental AnalystThe fundamentals behind the companyNothing, runs in parallel
Technical AnalystThe chart, and a proposed entry priceNothing, runs in parallel
Risk ManagerAn ATR-based stop-loss and a position sizeThe Technical Analyst's entry price
Chief StrategistThe final callAll four

The three analysts run side by side. The Risk Manager can't size a position without an entry price, so it waits for the Technical Analyst. The Chief Strategist reads everything and decides.

The agents share ten tool functions built on yfinance, ddgs and pandas-ta. None of them need an API key, which kept the project free to run and easy for anyone to clone.

The final answer has to match a strict schema, because the front end parses it straight into signal cards. Free text is not an output format.

One model, shared by every agent

It would be natural to give each agent its own model. On one GPU, that would be wasteful. All five agents share a single crewai.LLM, which talks to the self-hosted vLLM server through LiteLLM's hosted_vllm provider.

Sharing also plays to one of vLLM's strengths. Each agent's prompt starts with the same long role description every time it runs, and vLLM's prefix caching can reuse the work for a repeated prefix instead of recomputing it. I'm not quoting a speed-up figure here. Treat it as the reason for the design, not a benchmark.

Why vLLM and Qwen3-14B:

  • vLLM gives continuous batching, prefix caching and first-class ROCm 7.x support on the MI300X.
  • Qwen3-14B follows instructions and calls tools well, fits in about 28 GB of GPU memory, and the weights are open.

Never let the model invent a number you can look up

A 14B model will happily write a confident price that is weeks out of date. In a trading tool, that is the worst possible bug, because it looks exactly like a correct answer.

FinAgent treats the model's numbers as a shape, not as facts:

  1. The entry price comes from the live quote, not from the model.
  2. The stop-loss and target are rescaled around the live price, which keeps the risk and reward the model proposed but moves them onto reality.
  3. An automatic check replaces any price that drifts too far from the quote.
  4. If the output is too broken to parse, a deterministic fallback builds the signal from the live price, so the user gets an answer and not a crash.

Step 2 is easier to see in code. This is a simplified sketch of the idea, not FinAgent's actual implementation:

def anchor_to_live_price(entry, stop, target, live_price):
    """Keep the model's risk/reward shape, but move it onto the real price."""
    if entry <= 0 or live_price <= 0:
        raise ValueError("prices must be positive")
    scale = live_price / entry
    return live_price, round(stop * scale, 2), round(target * scale, 2)
 
# The model proposed entry 182.40, stop 176.90, target 193.40,
# a 2:1 reward to risk. The live quote is 171.05.
print(anchor_to_live_price(182.40, 176.90, 193.40, 171.05))
# (171.05, 165.89, 181.37), still 2:1

The general lesson goes well beyond trading. If a value exists in a system you can query, such as a price, a balance, a stock level or a date, fetch it. Let the model reason about it, never author it.

One bad ticker shouldn't sink the run

A watchlist might have ten tickers. If one of them has missing data or the model returns nonsense for it, the other nine still matter.

The runner records the error for that ticker in its CrewResult and carries on. The interface shows an error card for that one and normal cards for the rest. Partial success is a real state, and the UI should say so plainly.

Let people watch it think

Five agents take a while. A spinner for that long feels broken.

Every agent lifecycle event (task_start, task_complete, agent_output, task_failed and crew_error) goes out as a structured ActivityEvent through one callback. The Gradio front end on Hugging Face Spaces streams those events into an activity feed, so you see each agent start and finish instead of staring at a loader.

One correction, because an earlier description of FinAgent said the streaming runs "over WebSockets". It doesn't. My code is a Python generator that yields updates, and Gradio handles the transport. Gradio moved its queue from WebSockets to Server-Sent Events in version 4, and FinAgent is on Gradio 5. "Streaming" is the accurate word.

Test the rules, not the model

You can't unit-test whether a model's opinion of a stock is right. You can test everything around it. FinAgent has 309 tests written with pytest and Hypothesis. Hypothesis generates thousands of random inputs and checks that a rule holds for all of them. A few of the rules:

  • successful + failed == total_tickers, always. No ticker is ever lost or counted twice.
  • A formatted TradingSignal survives a round trip through the parser unchanged.
  • The vLLM health check reports failure for any response that isn't a 200.

Those properties are where the bugs actually live: in the glue code, the parsing and the counting, not in the model.

Treat the credit as the whole budget

Because it was. The GPU instance only runs while the front end is in use, so the $100 credit covered all the compute. On rented GPUs, an idle instance costs exactly as much as a busy one, so "off unless someone is using it" is the default worth designing for.

What I'd keep for the next agent system

  • Split the work into small roles with clear inputs, and make the dependencies explicit.
  • Share one model when the hardware is fixed, and let the server's caching help you.
  • Fetch facts, don't generate them. The model reasons. Your data sources supply numbers.
  • Design for partial failure, and show it honestly in the interface.
  • Stream progress so a slow pipeline feels alive.
  • Test the invariants around the model, because that is the code you can actually prove.

If you are building agents for real work rather than for a hackathon, the same habits apply, along with planning the work properly before the agent starts. I wrote about that in Spec-Driven Development: A Practical Guide with Examples.

Frequently asked questions

Why use several AI agents instead of one prompt?
Small roles are easier to reason about, test and fix than one giant prompt. In FinAgent, three analysts work in parallel, a risk manager waits for one of them, and a final strategist waits for all four, so each agent has one job and a clear input.
Can a 14B open model run a multi-agent system?
It can if the system is designed around its limits. FinAgent shares one Qwen3-14B, served by vLLM, across all five agents, and never trusts the model for numbers it can look up, such as the current price.
How do you stop an LLM inventing prices in a trading tool?
Anchor every number to live data. FinAgent takes the entry price from the live quote, rescales the model's stop-loss and target around it, replaces prices that drift too far, and falls back to a deterministic signal if the output cannot be parsed.
Are FinAgent's signals financial advice?
No. FinAgent is a hackathon project that shows a multi-agent architecture. Its output is not financial advice or a recommendation to trade.