use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;pub struct DailyNavEngine<'a> { sources: &'a SourceLake, cleaner: &'a Normalizer, peers: &'a PeerMatcher, spreads: &'a CreditSpreadCurve, gp_response: &'a GpResponseModel, cash_flows: &'a CashFlowLedger, store: &'a CleanStore,}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self, as_of: NaiveDate, ) -> CleanStore { let raw = self.sources.collect(as_of); let cleaned = self.cleaner.normalize(raw); self.store.replace(cleaned) } pub fn peer_proxy<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self .peers .match_size_and_industry(holding, as_of); peers.weighted_move(holding.last_gp_period(), as_of) } pub fn gp_response<'h>( &self, holding: &'h Holding, proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs .iter() .filter(|mark| mark.received <= as_of) .max_by_key(|mark| mark.period_end) .unwrap_or(&holding.entry_nav);

}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self, as_of: NaiveDate, ) -> CleanStore { let raw = self.sources.collect(as_of); let cleaned = self.cleaner.normalize(raw); self.store.replace(cleaned) } pub fn peer_proxy<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self .peers .match_size_and_industry(holding, as_of); peers.weighted_move(holding.last_gp_period(), as_of) } pub fn gp_response<'h>( &self, holding: &'h Holding, proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs .iter() .filter(|mark| mark.received <= as_of) .max_by_key(|mark| mark.period_end) .unwrap_or(&holding.entry_nav); self.gp_response.roll_forward(gp_nav, proxy, as_of) } pub fn private_credit_price( &self, loan: &LoanPosition, as_of: NaiveDate, ) -> (CleanPrice, DirtyPrice) { let spread: CreditSpread = self .spreads .for_rating(loan.rating, as_of); let clean = loan.cash_flows.discount(spread, as_of); let dirty = clean.with_accrued_interest(loan.accrued(as_of));

&self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self .peers .match_size_and_industry(holding, as_of); peers.weighted_move(holding.last_gp_period(), as_of) } pub fn gp_response<'h>( &self, holding: &'h Holding, proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs .iter() .filter(|mark| mark.received <= as_of) .max_by_key(|mark| mark.period_end) .unwrap_or(&holding.entry_nav); self.gp_response.roll_forward(gp_nav, proxy, as_of) } pub fn private_credit_price( &self, loan: &LoanPosition, as_of: NaiveDate, ) -> (CleanPrice, DirtyPrice) { let spread: CreditSpread = self .spreads .for_rating(loan.rating, as_of); let clean = loan.cash_flows.discount(spread, as_of); let dirty = clean.with_accrued_interest(loan.accrued(as_of)); (clean, dirty) } pub fn roll_forward<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> Valuation<'h> { let proxy = self.peer_proxy(holding, as_of); let mut value = self.gp_response(holding, &proxy, as_of); for flow in self.cash_flows.for_holding(holding, as_of) { value = value.apply_cash_flow(flow); }

proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs .iter() .filter(|mark| mark.received <= as_of) .max_by_key(|mark| mark.period_end) .unwrap_or(&holding.entry_nav); self.gp_response.roll_forward(gp_nav, proxy, as_of) } pub fn private_credit_price( &self, loan: &LoanPosition, as_of: NaiveDate, ) -> (CleanPrice, DirtyPrice) { let spread: CreditSpread = self .spreads .for_rating(loan.rating, as_of); let clean = loan.cash_flows.discount(spread, as_of); let dirty = clean.with_accrued_interest(loan.accrued(as_of)); (clean, dirty) } pub fn roll_forward<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> Valuation<'h> { let proxy = self.peer_proxy(holding, as_of); let mut value = self.gp_response(holding, &proxy, as_of); for flow in self.cash_flows.for_holding(holding, as_of) { value = value.apply_cash_flow(flow); } if let HoldingKind::PrivateCredit(loan) = &holding.kind { let (clean, dirty) = self.private_credit_price(loan, as_of); value = value.with_credit_prices(clean, dirty); } value } pub fn daily_nav( &self, fund: &Fund, as_of: NaiveDate, ) -> DailyNav { let valuations = fund

&self, loan: &LoanPosition, as_of: NaiveDate, ) -> (CleanPrice, DirtyPrice) { let spread: CreditSpread = self .spreads .for_rating(loan.rating, as_of); let clean = loan.cash_flows.discount(spread, as_of); let dirty = clean.with_accrued_interest(loan.accrued(as_of)); (clean, dirty) } pub fn roll_forward<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> Valuation<'h> { let proxy = self.peer_proxy(holding, as_of); let mut value = self.gp_response(holding, &proxy, as_of); for flow in self.cash_flows.for_holding(holding, as_of) { value = value.apply_cash_flow(flow); } if let HoldingKind::PrivateCredit(loan) = &holding.kind { let (clean, dirty) = self.private_credit_price(loan, as_of); value = value.with_credit_prices(clean, dirty); } value } pub fn daily_nav( &self, fund: &Fund, as_of: NaiveDate, ) -> DailyNav { let valuations = fund .holdings .iter() .map(|holding| self.roll_forward(holding, as_of)) .collect::<Vec<_>>(); DailyNav::from_holdings(fund, valuations, as_of) }}use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;

&self, holding: &'h Holding, as_of: NaiveDate, ) -> Valuation<'h> { let proxy = self.peer_proxy(holding, as_of); let mut value = self.gp_response(holding, &proxy, as_of); for flow in self.cash_flows.for_holding(holding, as_of) { value = value.apply_cash_flow(flow); } if let HoldingKind::PrivateCredit(loan) = &holding.kind { let (clean, dirty) = self.private_credit_price(loan, as_of); value = value.with_credit_prices(clean, dirty); } value } pub fn daily_nav( &self, fund: &Fund, as_of: NaiveDate, ) -> DailyNav { let valuations = fund .holdings .iter() .map(|holding| self.roll_forward(holding, as_of)) .collect::<Vec<_>>(); DailyNav::from_holdings(fund, valuations, as_of) }}use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;pub struct DailyNavEngine<'a> { sources: &'a SourceLake, cleaner: &'a Normalizer, peers: &'a PeerMatcher, spreads: &'a CreditSpreadCurve, gp_response: &'a GpResponseModel, cash_flows: &'a CashFlowLedger, store: &'a CleanStore,}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self,

value } pub fn daily_nav( &self, fund: &Fund, as_of: NaiveDate, ) -> DailyNav { let valuations = fund .holdings .iter() .map(|holding| self.roll_forward(holding, as_of)) .collect::<Vec<_>>(); DailyNav::from_holdings(fund, valuations, as_of) }}use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;pub struct DailyNavEngine<'a> { sources: &'a SourceLake, cleaner: &'a Normalizer, peers: &'a PeerMatcher, spreads: &'a CreditSpreadCurve, gp_response: &'a GpResponseModel, cash_flows: &'a CashFlowLedger, store: &'a CleanStore,}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self, as_of: NaiveDate, ) -> CleanStore { let raw = self.sources.collect(as_of); let cleaned = self.cleaner.normalize(raw); self.store.replace(cleaned) } pub fn peer_proxy<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self

DailyNav::from_holdings(fund, valuations, as_of) }}use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;pub struct DailyNavEngine<'a> { sources: &'a SourceLake, cleaner: &'a Normalizer, peers: &'a PeerMatcher, spreads: &'a CreditSpreadCurve, gp_response: &'a GpResponseModel, cash_flows: &'a CashFlowLedger, store: &'a CleanStore,}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self, as_of: NaiveDate, ) -> CleanStore { let raw = self.sources.collect(as_of); let cleaned = self.cleaner.normalize(raw); self.store.replace(cleaned) } pub fn peer_proxy<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self .peers .match_size_and_industry(holding, as_of); peers.weighted_move(holding.last_gp_period(), as_of) } pub fn gp_response<'h>( &self, holding: &'h Holding, proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs

Built on mathematics, not a brand.

Our models are proprietary, deterministic and fully automated. Every holding is valued by code, not AI.

One mathematical framework values bottom up or top down, calibrated to the market in general or to each holding, without conflict.

Model status

Alts-Align PipelineTodayOperationalQ1 2026Q2 2026Q3 2026Q4 2026100% uptime

FEV PipelinesTodayOperationalQ1 2026Q2 2026Q3 2026Q4 2026100% uptime

Daily ValuationTodayOperationalQ1 2026Q2 2026Q3 2026Q4 2026100% uptime

Bias vs. GP Actuals: <1%
Per fund valuation time: .6s
Data points per fund: 2m

Valuation is a measurement, not an opinion

Most private valuation is a subjective accounting opinion, rendered and defended quarter by quarter. Ours is a measurement, made by deterministic code and mathematics. It returns a value the same way every time, across 90,000 assets in under 90 seconds.

FEV was a math problem before it was a company

FEV started in Seattle in 2013 with a question Dr. Sidney C. Porter (PhD in mathematics, Yale) kept encountering. If the price of a private company cannot be observed, can its value still be measured? He addressed it as math, not accounting.

The answer became the FEV model. A company's fundamental economic value, plus a premium for the market's forward-looking sentiment, gives its price. The solution is scalable and objective, with low bias and traceability from each holding up to the portfolio, and reaches an R² of 0.87 against the prices assets actually exit at.

What is a custom proxy?

A hyper-specific benchmark built for each holding, a virtual investment in the public companies most like it, chosen and kept current by an objective, automated process.

Most valuation puts one index on a whole sector. But two holdings in the same sector are still different companies, and an index that does not move like the asset misses what is specific to it, which introduces error. So every holding gets a proxy of its own and is valued against the companies most like it, every trading day.

One for every holding
Built for the holding itself, never shared across a fund or a sector, its companies matched to it on size, industry and operating fundamentals.
50 to 150 companies
Enough that no single company can move it, and few enough that each one resembles the holding. Robust and specific at once.
Calibrated every day
It moves with the market every trading day, and the same method rebalances it for major cash flows, bolt-ons and companies that leave it.

Not just a simple beta.

There are two ways to value a private fund. Assume a ratio, or measure every holding in it from the data up. Our models measure.

A simple beta

AssumedOne fixed ratio, keyed into a spreadsheet, multiplies the whole fund. Nothing in it is derived from the holdings.
One number for the fundThe holdings inside go unvalued, so the fund's number cannot be checked against them.
Set by handSomeone chooses the ratio, so the result depends on who chose it and when.
Nothing to validateThe ratio is a subjective number someone came up with, not an objective measure. With no inputs to test, there is nothing to check and nothing to learn from.
Backed by a brandThe firm's name and reputation stand in for a method, so a careless valuation can pass on the brand alone.

Our models

Mathematically derivedEach value is worked out from thousands of data points for each holding.
Every holding, up to the portfolioEach holding is valued, then rolled into its fund and the portfolio by one framework, so every level agrees, bottom up and top down.
Deterministic and automatedCode runs every step and the models never change on their own, so running a valuation again gives the same value. Any change to them goes through a formal review by our data scientists.
Validated and testedEvery value passes automated validations and an analyst's review before it reaches you. Each quarter we test our estimates against the GP marks reported after them, and the results guide our research.
Backed by mathematicsWe exercise the data every trading day, and have for over 10 years. Peer-reviewed research stands behind every number.

For asset managers: Values that follow each holding, rather than the whole market, mean less volatility to explain and more confidence from your investors.
For LPs and asset owners: You make decisions on how your assets actually behave, and you learn something from the data rather than only receive a number.

Our models are built to work with the messy reality of private markets.

Private market data is sparse. Each GP reports weeks or even months after quarter end, in its own format. Our models are built for that reality. Every trading day they value each holding from what has arrived, by the same method, and fold in each new GP report as it arrives. The estimate then trues up to the GP's mark, and the closer it was, the less the true-up moves your NAV. We care about accuracy because you care about price volatility.

Built for every private asset class

Private Equity
AI is changing what software businesses are worth, and public software stocks reprice with each development while GP marks arrive weeks to months after quarter end. We value each holding in venture, growth and buyout funds every trading day against public companies that map to its size and industry, so the fund's NAV reflects the change between reports.
Private Credit
Sentiment toward private credit has turned quickly, with spreads widening most on loans to software borrowers. We calibrate each loan, in a fund or held directly, to the bond market at entry, then move it every trading day with credit spreads and interest rates. Its interest accrues between reports, PIK included, and we report it at both a clean and a dirty price.
Infrastructure
Private funds are financing data centers, power generation and transmission to meet demand from AI and electrification, and they report on these assets quarterly. Our models value each fund and project every trading day in between, against the market signals that explain its economics.
Real Estate
Listed real estate reprices every trading day while private appraisals adjust gradually, and the gap between public and private values has persisted since higher rates reset property prices. We roll each fund, private REIT and separately managed account forward daily from its last reported value, counting market movement and each cash flow on the day it happens, so market pricing reaches it between appraisals.

Every input is traceable. Every output is testable. Every valuation is auditable.

Lineage and audit trails are part of the pipeline itself.

We keep the record of every run, so any past valuation can be reproduced and explained.

Breakthrough technology. Disruptive pricing.

The most direct test of a valuation method is to watch it run on a real portfolio.

We will value one of your portfolios.

Get Started

Built on mathematics, not a brand.

Model status

Valuation is a measurement, not an opinion

FEV was a math problem before it was a company

What is a custom proxy?

One for every holding

50 to 150 companies

Calibrated every day

Not just a simple beta.

A simple beta

Our models

Our models are built to work with the messy reality of private markets.

Built for every private asset class

Private Equity

Private Credit

Infrastructure

Real Estate

Every input is traceable. Every output is testable. Every valuation is auditable.

Breakthrough technology. Disruptive pricing.