WEBI - We buy | Your AI copilot for structured bond deals

WEBI is the AI copilot for structured bond products. We turn fragmented bank deal flow into ranked opportunities auto-matched to each fund's mandate, with gap analysis and counter-offer suggestions.

Comment

Inspiration

Walk into any family office or asset management desk in Paris, Geneva, or Luxembourg, and you'll see the same scene play out every morning: a Structured Product Analyst, three monitors deep, scrolling through hundreds of Bloomberg messages and emails from banks. Each one pitches a structured bond product. Each one needs to be cross-checked against the fund's investment policy, risk tolerance, sector exposures, currency rules, and a dozen other constraints, most of them implicit, sitting in the analyst's head.

During the hackathon, we talked to people doing this job. The pattern was striking:

  • 70% of their day is spent manually filtering offers that will never match the mandate.
  • The 30% that fit is rushed through under pressure, with limited time for negotiation, even though structured products are meant to be negotiated.
  • And worst of all: opportunities are missed, not because they don't exist, but because they got buried in the inbox of the wrong analyst.

The buy-side is drowning in deal flow. The sell-side is shouting into a void. Nobody is happy. We saw an obvious gap and built WEBI to close it.

What it does

WEBI is an AI copilot that transforms unstructured bank deal flow into a curated, mandate-matched, negotiation-ready pipeline.

The product works in three layers, each compounding the value of the last.

Layer 1 – The Intelligent Filter

WEBI automatically ingests bank communications across multiple channels: emails, Bloomberg chats, and term sheet PDFs. Using Gemini 2.0 Flash for structured extraction and a FAISS vector index for semantic mandate matching, it extracts 17-field JSON representations of every product (issuer, underlying, coupon, barrier, maturity, ratings, currency, ESG flags, etc.) and matches them against each fund's codified mandate:

  • Auto-Reject – products that violate hard constraints (e.g., principal protection required, no Russian underlyings) are silenced immediately.
  • High-Confidence Matches – products that hit ≥ 90% of criteria are pushed to the analyst's dashboard with a transparent matching score and an explanation.
  • Near-Misses (Gap Analysis) – when a product almost fits but fails on one parameter (e.g., coupon at 4% vs mandate-required 4.5%), WEBI doesn't trash it. It flags it as a negotiation opportunity and drafts a counter-offer.

Layer 2 – The Negotiation Engine

This is where WEBI breaks new ground. Most tools stop at filtering. We go further: 80% of structured products in the market are adjusted post-discussion with the issuing bank. WEBI surfaces those near-misses and tells the analyst exactly what to negotiate, which parameter to push, by how much, and why the fund is justified in asking.

Layer 3 – Market Discovery (The Web)

WEBI doesn't just process what each fund receives. It builds, securely and anonymously, a cross-fund signal layer: if Family Office A receives a deal that fits Family Office B's mandate better, WEBI flags the connection. We become the routing layer that makes the entire structured products market more efficient.

Built for Multi-Family Offices

Single-mandate funds are easy. Multi-Family Offices, where one analyst juggles 50 client portfolios with 50 different mandates, are the real battlefield. WEBI runs every incoming deal against the entire mandate database simultaneously: one feed, multiple mandates, instant routing.

How we built it

We architected WEBI as a modular pipeline, optimized for both speed during the hackathon and scalability for the real product.

Ingestion layer

  • Email and Bloomberg chat parsers built around standard MIME and chat-export formats.
  • PDF extraction using a layout-aware parser to handle term sheets that mix tables, footnotes, and disclaimers.
  • A unified ingestion bus that feeds everything into the same downstream pipeline.

Extraction & normalization

  • LLM-powered structured extraction (Gemini 2.0 Flash) with a strict JSON schema covering 17 fields per product (issuer, type, underlying, payoff structure, barriers, maturity, coupon, currency, ratings, ESG tags, etc.) and per-field confidence scores.
  • A validation layer that flags incomplete or ambiguous extractions for human review, critical in finance, where a hallucinated coupon could be catastrophic.

Mandate codification

  • Each fund's Investment Policy Statement is parsed into a machine-readable constraint graph: hard rules (principal protection, exclusion lists), soft preferences (preferred sectors, duration buckets), and learned patterns from historical purchases.
  • The constraint graph is versioned, when a PM changes their tactical view, WEBI re-evaluates all open opportunities.

Matching & scoring

The scoring combines three signals with explicit weights:

$$\text{score} = 0.25 \cdot s_{\text{semantic}} + 0.25 \cdot s_{\text{constraints}} + 0.20 \cdot s_{\text{yield}} + 0.15 \cdot s_{\text{exposure}} + 0.15 \cdot s_{\text{market}}$$

  • \( s_{\text{semantic}} \) – cosine similarity between Gemini-embedded product and mandate canonical texts (768-dim FAISS IndexFlatIP).
  • \( s_{\text{constraints}} \) – hard-constraint compliance; hard-fail products are penalized: \( \text{score} \times 0.35 \).
  • \( s_{\text{yield}}, s_{\text{exposure}}, s_{\text{market}} \) – continuous soft-preference alignment.

Every score is fully decomposable so the analyst can defend the recommendation in front of the investment committee.

Frontend

  • Built with React 18 + TypeScript for the dashboard.
  • A clean three-panel layout: Inbox (raw flow) → Opportunity Feed (matched) → Negotiation Queue (near-misses with counter-offer drafts).
  • Reactive UI: the feed updates as new deals are ingested, with live backend and Gemini status indicators.

Infrastructure

  • Backend in Python (FastAPI) for the ingestion and matching pipelines.
  • Vector storage in FAISS, structured data in PostgreSQL.
  • Logical data isolation by tenant: each fund's data, mandates, and signals are separated at the query layer.

Challenges we ran into

1. Extracting structure from genuinely messy documents

Term sheets are written by lawyers and traders for lawyers and traders. Tables wrap across pages, footnotes contradict the main text, and the same product is described three different ways depending on the bank. Our first naive prompt extracted 60% of fields correctly. We iterated through five versions of the schema, added a self-validation step where the LLM cross-checks its own extraction against per-field confidence scores, and reached >90% field accuracy on our test set.

2. The "implicit mandate" problem

Investment Policy Statements written on paper are a fraction of how funds actually decide. Most of the rules live in the analyst's head, "we don't touch anything from issuer X since 2022", "the boss hates Asian underlyings on Mondays". We solved this with a hybrid approach: explicit codification of the IPS plus continuous learning from accept/reject decisions, so the system gradually internalizes the unwritten rules.

3. Building negotiation logic without market data

Suggesting "ask for 50bps more" requires a sense of what's actually negotiable. Without access to a real bond pricing engine, we built a heuristic benchmarking layer based on the spread between similar products in our simulated flow. It's not perfect, but it shows the right direction, and points to a clear data partnership opportunity post-hackathon.

4. UX for a high-stakes audience

Portfolio managers don't trust black boxes. Every WEBI recommendation had to be explainable in one glance, why this deal, why now, what's the catch. We rebuilt the dashboard three times before landing on a layout that conveys the matching score, the rationale, and the negotiation angle without overwhelming the user.

Accomplishments that we're proud of

  • A working end-to-end pipeline that ingests a real Bloomberg-style email, extracts a structured product into clean JSON, scores it against five different mandates, and surfaces a ranked feed with explanations, in under 8 seconds per deal.
  • The negotiation engine actually works: in our demo, we feed in a near-miss and WEBI outputs a coherent counter-offer with the exact parameter to adjust and the financial logic behind it.
  • Multi-mandate routing running on five simulated portfolios with conflicting mandates (Conservative, Aggressive, ESG, Yield-Enhancement, Defensive), the same deal correctly gets accepted by one, rejected by another, and flagged for negotiation by a third.
  • A polished, B2B-grade interface that doesn't look like a hackathon project, because in finance, trust starts with the visual.
  • A defensible data moat thesis: we mapped how each new fund onboarded compounds the value of the matching graph, the negotiation benchmarks, and the cross-fund discovery layer.

What we learned

  • Finance UX is brutally honest. Every extra click costs you the user. Every unexplained recommendation costs you the trust. We learned to design for an audience with zero patience and infinite scrutiny.
  • LLMs are powerful but not autonomous in regulated workflows. The right pattern isn't full automation; it's a copilot architecture where the AI does the heavy lifting and the human keeps the final call. Compliance, MiFID II, and the cost of a bad trade make anything else unshippable.
  • The real moat is not the model; it's the data graph. Anyone can wrap an LLM around a term sheet. Almost nobody can build, over time, the cross-fund mandate database that makes intelligent routing possible.
  • B2B fintech wedge strategy matters. We started this project thinking "we'll sell to everyone in asset management." We finished it convinced that family offices are the perfect beachhead: short sales cycles, single decision-makers, acute pain, underserved by existing tools.

What's next for WEBI

Next 3 months – Design partners

Close 5 family office design partners in Geneva, Paris, and Luxembourg. Build the v1 in production with their real flow. Validate that the negotiation engine generates measurable economic value (target: +20–40 bps captured per negotiated deal).

6–12 months – Vertical expansion within the buy-side

Expand from family offices to mid-cap asset management boutiques (€5–50bn AUM). Onboard the first multi-family offices with 20+ mandates. Build the compliance and audit-trail layer required for institutional adoption (MiFID II, SOC 2).

12–24 months – The marketplace flips

Once we have 50+ active buy-side users, we open the platform to issuing banks who can push their flow directly into WEBI's standardized format. The economic gravity reverses: instead of banks broadcasting blindly, they bid for relevance against a curated, mandate-aware demand signal.

Long-term – Beyond structured bonds

Structured bonds are the wedge, not the endgame. The same platform, multi-channel ingestion, mandate codification, intelligent matching, extends naturally to private placements, primary bond issuance, IPO allocations, and block trades. We're building the deal flow operating system of the buy-side.

Our north star: every euro invested in structured products by a buy-side firm passes through an intelligent matching layer. We want that layer to be WEBI.

Built With

Share this project:

Updates