Andrew Jorge

Built an interactive assumption tester in R for the private equity valuation team: analysts slide pricing and entry/exit variables and watch valuation, leveraged-buyout returns, and assumption drift recompute in ~1ms, spanning 49 pricing-assumption combinations, 36 entry-and-exit combinations, and 5 model versions, with a browser-side Excel upload and field-tagging that streamlines translation into CSV. Demoed it to a VP, who deemed it fit-for-purpose.

Automated a RAG Q&A tool with exact citations for the Capital Markets team's diligence, citations served from cache before touching raw sources, so every answer is traceable. Shipped an earnings report summarizer for the investment team, conditioned on 20+ prior analyst-written summaries so output matches house style, the difference between a tool analysts adopt and one they ignore.

Built a working RAG prototype over internal IT documentation: hybrid BM25 + FAISS dense retrieval fused by reciprocal rank fusion, a cross-encoder second pass that re-reads the top 40 passages and keeps the 5 most relevant, and a confidence gate that declines below 0.60, scored against the chunks the model actually cited. Designed a RAGAS evaluation framework over a labeled Q&A set (10% deliberately declinable) to catch over-confident answers.

A few courses that shaped how I build, less the syllabus, more what stuck:

An interactive tool for reading a codebase by its structure. Every file is parsed via tree-sitter into nested, selectable pieces, function, block, and expression, drawn over the source and chunked live, aware of structure boundaries down to a single character. Three sliders shape the slicing: granularity, how deep to split; depth spread, how far apart the chosen depths may sit; and context detail, how finely large files are summarized for the AI under a word-count cap.

Each piece carries a stable identity derived from the tree rather than the current zoom, so understanding accumulates across re-chunking instead of being thrown away. Meanings are computed recursively and cached against those identities, so a snippet's standalone meaning is computed once and reused wherever it recurs, and different slicings of a file share their common ancestors, then folded with surrounding scope up through the folder tree so an answer about a single line can draw on the whole project.

Question-answering is retrieval the user steers. The selected piece is the unit, so there is no vector database; the access pattern is an exact-key lookup along one path rather than a similarity search. The meaning cache is content-addressed and self-invalidating, since edited code yields new keys and stale entries are simply never read again, backed by a plain on-disk file with an in-memory layer rather than a standing service. Two Anthropic models are routed by the weight of each read and write request, cutting cost without losing answer quality.

A point-in-time credit stress monitor for 13 financial-services sub-sectors, deployed end-to-end on Northflank and Vercel. ~25,000 macro observations from FRED and yfinance, carrying full revision history back to 1990 and updating live. Dual-timestamp Postgres eliminates look-ahead bias from FRED revisions, so the stress picture for any past date is rebuilt using only the data published by then, never peeking at the future.

182 per-sector indicator weights, each derived empirically via OLS regression and exposed as a live slider, so the model can be re-weighted and replayed at query time.

Designed an entity-resolution pipeline across FDIC and SEC EDGAR to assemble a dataset no single source publishes: 71 bank acquisitions enriched with real deal prices, resolved out of ~11,300 merger records. Then validated a deal-pricing model out-of-sample, trained on pre-2020 deals, tested on later ones, and reported the honest null: macro conditions alone do not predict deal pricing (R² ≈ 0.09).

~5,000-line vanilla JS dashboard over a 20-endpoint FastAPI backend, with idempotent, crash-recoverable loaders.

An observability layer and SDK for LLM agents that turns any Python function into a tool, building its schema from type hints and the docstring. Real-time ReAct visualization and SSE streaming log every event, 10 kinds in all, tool calls, model calls, errors, with cost tracked to $0.000001. Any sub-agent opens in under 50ms over a single live connection, however deeply nested, cutting failure root-cause to under two minutes.

O(1) cycle detection threads an immutable frozenset call chain through every sub-agent invocation, preventing recursive loops without locks and without blocking parallel sub-agents; config is snapshotted at run start so mid-flight edits never corrupt a run. SQLite persists versioned run history, so agent behavior can be compared across model, prompt, and tool changes. Hardened on a data-analyst agent (7 tools, 3 chart types) that decides on its own when a chart conveys more than prose.

A wellness model that works from the body signals underneath a goal rather than the goal alone. Trends in signals like sleep are mapped into seven research-grounded constructs of body state, each computed from its own equation over those inputs, and tied to how much real progress a person is making.

An AI interview captures the goal, what progress actually means to the person, and the body states that bear on it. From there a goal-specific chat translates any activity they are weighing into a quantified cost against that goal, so a late night or a skipped workout reads as a concrete tax rather than a vague maybe-don't. The chat recalibrates how heavily each signal counts as it goes, learning from the somatic symptoms the person reports back.

A personal knowledge-graph app for mapping a subject as a network of ideas and relationships. The model generates the initial graph from notes or an uploaded PDF, then expands and corrects it via a typed GraphDelta diff schema (add, update, delete) rather than regenerating the full graph.

A reflection mode walks the graph breadth-first, prompting the user to articulate each concept; those articulations feed back into the next graph update, closing the loop between user understanding and graph structure. Every model call is typed via Pydantic schemas, so malformed responses fail loudly instead of silently corrupting state.

An event-streaming pipeline with LLM-powered schema repair and human-in-the-loop approval. Kafka ingests events; Great Expectations validates them; a LangGraph agent proposes targeted repairs for failures; a FastAPI dashboard lets a human (or an optional autopilot) approve or reject each proposal.

Postgres is the coordination layer and the audit trail. Every event, every agent proposal, every human decision is persisted and replayable.