TrustLens VC — Project Story
Inspiration
The idea for TrustLens VC came from a frustrating reality in venture capital: the information asymmetry between startups and investors is enormous, but somehow it's the investors who are drowning.
A typical VC partner evaluates hundreds of startups per quarter. For each one, they manually scan pitch decks, cross-reference founder claims against LinkedIn profiles, search for competitive signals on Twitter, check GitHub repos for engineering quality, and read SEC filings for comparable exits. This process takes 40+ hours per deal — and even then, critical contradictions slip through. A founder claims "5 years building ML infrastructure at Google," but their LinkedIn shows 18 months in a tangentially related role. Nobody catches it until the third partner meeting.
Then there's the delivery problem. Analyst teams build dashboards, chat interfaces, internal tools — and partners never use them. Partners work on calls, in cars, between board meetings. They don't open dashboards. They don't type into chatbots. They pick up the phone.
That's what inspired TrustLens VC: what if a partner could call a phone number, ask about a startup, and hear a thesis-aligned score spoken back in real time — while the system continuously improves itself behind the scenes?
What We Learned
Scoring has to be thesis-specific
Early on, we assumed startup evaluation could be reduced to a single heuristic: aggregate some data, run it through an LLM, get a number. We were wrong.
Different VCs care about fundamentally different things. A growth-stage infrastructure fund weights technical moat heavily. A seed-stage consumer fund cares more about market timing and founder charisma. We needed a configurable scoring model — one where each dimension could be independently weighted and the signals feeding into it were transparent.
We settled on a five-dimensional thesis-aligned model:
$$S_{\text{total}} = \sum_{i=1}^{5} w_i \cdot s_i$$
where each $s_i \in [0, 10]$ represents a dimension score and $w_i$ is the thesis weight, with the constraint:
$$\sum_{i=1}^{5} w_i = 1.0$$
The default configuration, calibrated for growth-stage enterprise infrastructure investing, uses:
| Dimension | Weight ($w_i$) |
|---|---|
| Technical Moat & Differentiation | 0.25 |
| Capital Efficiency & Scale Path | 0.20 |
| Founder-Market Fit | 0.20 |
| Market Timing & Density | 0.20 |
| Commercialization Traction | 0.15 |
Each dimension is itself a composite. Founder-Market Fit, for example, is the weighted average of six sub-signals:
$$s_{\text{founder}} = \frac{1}{6}\sum_{j=1}^{6} f_j$$
where $f_j$ covers LinkedIn consistency, GitHub depth, social proof, claim verification, network quality, and domain expertise. The claim verification component is particularly important — it catches contradictions between what a founder says and what the data shows.
Voice changes everything
The biggest insight wasn't technical — it was about user behavior. We built text interfaces first. Partners didn't use them. The moment we put Bland AI in front of the system and gave partners a phone number to call, adoption went from zero to daily use. Voice isn't a nice-to-have for this audience. It's the only interface that fits their workflow.
The system has to improve itself
Static scoring models decay. Market conditions shift, new sectors emerge, and what counted as a "strong moat" in 2024 looks different in 2026. We learned that building in continuous optimization from day one — not as a future feature — was essential to keeping the system trustworthy over time.
How We Built It
The eight-technology architecture
TrustLens VC is built on eight technologies, each filling a role that would be impossible to replicate without it. The pipeline operates in two layers: a core runtime path that handles every query, and a development-time layer that ensures the system is built correctly and stays healthy.
Kiro — Spec-Driven Development. AWS's agentic IDE transforms the investment thesis into formal specifications before any code is generated. Requirements, Design, Tasks — validated before a single line is written. When a fund changes its thesis weights or adds a new scoring dimension, Kiro replans the implementation automatically. This means thesis changes propagate cleanly through the codebase instead of accumulating as patches.
Auth0 — Identity for Humans and Agents. Auth0 for AI Agents gives both the VC analyst and the AI agent their own identities with Fine-Grained Authorization. This ensures the agent only retrieves documents the analyst has permission to see. A principal shouldn't see the same deal intelligence as a managing partner. SSO, MFA, and passkeys are built in from day one — not bolted on later.
Bland AI — Self-Hosted Voice Delivery. This is the interface layer that changed everything. Partners call a phone number and talk to TrustLens. Bland's self-hosted infrastructure means deal intelligence never leaves the firm's servers — critical when discussing pre-announcement fundraising signals. The platform supports a million concurrent calls with sub-second latency, so an entire partnership can use it simultaneously during a Monday meeting.
Airbyte — Continuous Data Pipelines. 600+ pre-built connectors create persistent pipelines from LinkedIn, GitHub, Crunchbase, SEC filings, news feeds, and CRM systems. Agent Connectors let the AI trigger syncs and write back enriched data. The key distinction: data flows continuously in the background, not on demand when someone asks a question. By the time a partner calls, the data is already there.
Aerospike — Real-Time Vector + Graph Database. Aerospike's multi-model engine handles key-value, document, graph, and vector search in a single system. The self-healing HNSW index searches billions of vectors in milliseconds for semantic similarity across the deal corpus. Graph data maps founder networks and investor co-occurrence patterns — surfacing connections that no keyword search would reveal. Running vector and graph in one database eliminates the latency of cross-system joins.
TrueFoundry — Production Deployment and Observability. TrueFoundry deploys the entire agent as a containerized, governed production service. The AI Gateway tracks every agent action — which data sources were consulted, which scoring functions fired, what the intermediate results were. Full observability with Grafana and Datadog integration means the ops team sees exactly what's happening. Auto-scaling handles everything from a single ad-hoc query to an entire team querying simultaneously during a partner meeting.
Overmind — Continuous Agent Optimization. Built by a former MI5 intelligence officer, Overmind applies pattern-of-life analysis to detect scoring drift — when the agent's outputs start diverging from the patterns that correlate with good investment decisions. Reinforcement learning corrects deviations automatically. The agent doesn't just stay accurate. It gets better over time as more deals are scored and outcomes are observed.
Macroscope — Codebase Understanding Engine. With 98% precision code review on every pull request, Macroscope catches production-critical bugs before they ship. Its AST-based code walking understands how the scoring engine actually works — not just pattern matching against text, but structural understanding of the logic. When someone asks "how does the capital efficiency score interact with the hiring velocity signal?", Macroscope answers from the code itself.
The runtime pipeline
When a partner calls TrustLens and asks about a startup, the eight technologies fire in sequence:
$$\text{Auth0} \xrightarrow{\text{identity}} \text{Airbyte} \xrightarrow{\text{data}} \text{Aerospike} \xrightarrow{\text{search}} \text{TrueFoundry} \xrightarrow{\text{serve}} \text{Bland AI}$$
with Overmind running continuously in the background optimizing the scoring model, Kiro managing the development lifecycle, and Macroscope maintaining code health.
A typical query resolves in about 8 seconds — from phone ring to spoken thesis-aligned score.
Development layer
Kiro, Overmind, and Macroscope form the development and maintenance layer. Kiro ensures thesis changes are implemented spec-first rather than ad hoc. Overmind ensures the scoring model improves with every interaction. Macroscope ensures the codebase stays understandable and production-safe as the system grows. Together, they create a system that is not just built well, but stays well-built over time.
Challenges We Faced
Voice latency under load
Bland AI's sub-second latency is impressive in isolation, but the full pipeline — Auth0 verification, Aerospike vector search plus graph traversal, TrueFoundry agent serving, and Bland speech synthesis — adds up. Getting the end-to-end response under 8 seconds required careful optimization: pre-warming Aerospike indexes, using Airbyte's continuous sync to eliminate on-demand data fetching, and leveraging TrueFoundry's auto-scaling to keep agent instances warm. The difference between 8 seconds and 15 seconds is the difference between a natural conversation and an awkward silence.
Identity for agents, not just humans
Auth0's human identity flow is well-understood. But TrustLens has an AI agent that also needs its own identity — it queries data sources, writes back to the CRM, and generates documents. Auth0 for AI Agents solved this, but designing the Fine-Grained Authorization model — determining which data the agent can access on behalf of which analyst at which access tier — required careful thought. A principal's agent shouldn't see the same deal intelligence as a managing partner's agent.
Continuous data without drowning in noise
Airbyte's 600+ connectors are powerful, but continuous sync from 12+ sources generates enormous volumes of data. Not all of it is relevant. We had to design filtering layers that reduce the firehose to actionable signals before they hit Aerospike — otherwise the vector corpus fills with noise and search quality degrades. Balancing freshness against relevance was one of the hardest engineering problems in the project.
Scoring drift detection
Overmind's pattern-of-life analysis is designed for continuous systems, but VC deal flow is inherently lumpy — some weeks have 20 new signals, others have 2. Detecting genuine scoring drift versus normal variance in sparse data required tuning Overmind's reinforcement learning to account for the irregular cadence of venture deal flow. A scoring model that "corrects" itself during a quiet week can actually introduce drift rather than fix it.
Keeping the codebase understandable as scoring logic grows
Each new thesis dimension adds scoring functions, sub-signals, and cross-references. After five dimensions with six sub-components each, the scoring engine had 30+ interacting functions. Macroscope's AST-based code walking became essential — not just for catching bugs, but for answering questions like "what happens to the overall score if we change the capital efficiency weight from 0.20 to 0.30?" Without structural code understanding, these questions require manual tracing through dozens of files.
Self-hosting voice infrastructure
The decision to self-host Bland AI (rather than using their cloud) was driven by deal confidentiality — pre-announcement fundraising intelligence cannot leave the firm's infrastructure. But self-hosting means managing the voice infrastructure: scaling, failover, latency monitoring, and audio quality. TrueFoundry's containerized deployment and observability stack made this manageable, but it added operational complexity that a cloud-hosted voice solution would have abstracted away.
What's Next
TrustLens VC today delivers voice-first, self-improving deal flow intelligence. But we see three areas for expansion. First, multi-modal input: letting partners share a pitch deck photo during a call and get instant analysis. Second, outcome feedback loops: connecting Overmind to actual investment outcomes (passed, invested, returned capital) to close the reinforcement learning loop with real data. Third, cross-fund pattern detection: with permission, identifying thesis-level patterns across multiple funds to surface meta-insights about what's working in the market.
The goal remains the same: make every first meeting feel like a third meeting, and deliver intelligence the way partners actually work — by voice, in real time, getting smarter every day.
Log in or sign up for Devpost to join the conversation.