CLAW · DISTILL · HAGGLE

The agent that finds your one winning product

An arbitrage dropship recommender: Reflex watches what you search for, hunts the price gap between local sourcing and EU prices, and negotiates the deal. An entry for the NVIDIA Claw Agent Challenge (Barcelona).

0
accuracy on held-out deals
0
per judgment, System One
0
decided with zero LLM calls
0
tests green
Live simulation

Watch it work

A scripted replay of a real run — the same flow as the live dashboard. It hunts, it picks, it negotiates.

reflex · triage cycle SIMULATED LIVE
Real dashboard demo recording
The real thing. Dashboard recording (offline demo): triage cycle on v2 ID→EU pairs, then a simulated negotiation — $16.00 → $15.29, deal at 500 units.

📊 Open the pitch deck 12 slides · also as PDF

Screenshots

From the real dashboard

The live Flask demo, driven end-to-end: real Amazon products, live supplier search, simulated negotiation.

The design

Four pictures, the whole idea

The architecture, drawn for humans: the loop, the distillation, the Jev-style typed head, and the haggle.

The idea

Buy where it's cheap.
Sell where it's expensive.

Cross-border arbitrage is simple. Finding the one product worth working — before everyone else — is the hard part. Reflex does it in five steps:

01

Your top searches

What you keep looking up is your edge — the niche you understand. The agent hunts there, not in generic trend lists.

02

Margin-gap scan

For products in your space it compares local sourcing cost vs EU retail and does the margin math.

03

The one

Not fifty maybes — the single best risk-adjusted opportunity, picked by your distilled deal instinct.

04

Verify

The slow brain stress-tests it: competition, shipping, quality risk — before a cent is considered.

05

Work the deal

Finds suppliers, drafts outreach, rehearses the negotiation. Money never moves without you.

The novelty

Your deal criteria, distilled

Psychologist Daniel Kahneman showed humans think in two systems — fast instinct, slow analysis. Reflex is built the same way. The fast one is the breakthrough: a tiny model that is a compressed copy of your judgment. Like espresso from a pot of coffee — all the flavor, none of the volume.

🟢 System One🔵 System Two
WhatYour distilled deal instinctA large AI analyst (your OpenAI-compatible LLM)
Speed~16 milliseconds~10–60 seconds
CostFree, runs on your laptopPaid API call
HandlesScreening thousands of candidatesVerifying the one opportunity

Every verdict is typed — shortlist / pass / research with a calibrated probability and a rationale — and the Noul safety gate sits in front of everything consequential: the agent can research, draft, and negotiate, but it can never move money without you. Reflex recommends; it never transacts.

Under the hood

Source code

The full repo is MIT-style open. Two pieces carry the whole design:

reflex/ ├── system_one/ # the distilled head — DecisionHead protocol ├── system_two/ # slow analyst: OpenAI-compatible → Hermes/NIM → offline ├── negotiation/ # Exa supplier search, drafts, simulated rounds ├── deepagent/ # scout / judge / analyst subagents + tools ├── serve/ # the 24/7 claw loop (scan → judge → digest) ├── noul.py # safety gate: talks, never transacts ├── memory.py # SQLite: products, judgments, deals └── web/ # the dashboard
reflex/system_one/__init__.py — the DecisionHead protocol
class DecisionHead(Protocol):
    version: str

    def judge(self, product: Product) -> Judgment: ...
    def judge_batch(self, products: list[Product]) -> list[Judgment]: ...


class SklearnHead:
    """Calibrated gradient boosting head trained on personal labels."""

    def __init__(self, settings: Settings | None = None):
        base = HistGradientBoostingClassifier(
            max_iter=300, learning_rate=0.06, max_leaf_nodes=31,
            min_samples_leaf=20, l2_regularization=1.0, random_state=7,
        )
        self.model = CalibratedClassifierCV(base, method="sigmoid", cv=3)
reflex/noul.py — the safety gate
# Money movement / commitment — blocked.
_BLOCKED = re.compile(
    r"\b(buy|purchase|order|checkout|pay|payment|transfer|wire|deposit|"
    r"pre-?order|send money|charge (my|the) card|place .*order|"
    r"close the deal|sign .*contract|send .*contract)\b",
    re.IGNORECASE,
)

def check(action: str) -> NoulVerdict:
    """Return allowed=False for anything that moves money."""
    ...
    if _BLOCKED.search(action):
        return NoulVerdict(action=action, allowed=False, reason=(
            "Noul safety gate: this action would move money. "
            "Reflex drafts and negotiates; it never transacts "
            "without your approval."))

View the full repo on GitHub

Try it

One click to a live demo

Spin up the whole thing in your browser — no local setup. The dashboard starts automatically in offline demo mode; add your OPENAI_API_KEY + EXA_API_KEY as Codespaces secrets and it goes live.

Open in GitHub Codespaces

Prefer local? Quickstart in the README — three commands to the dashboard.

OPENAI_API_KEY=your-key EXA_API_KEY=your-key \
  .venv/bin/python -m reflex.web.app --port 8765
# → http://localhost:8765