Sowfin: Knowledge Cores for Agentic Corporate Finance

Sowfin is a modern AI-powered corporate finance platform that leverages TrustGraph's Knowledge Cores to deliver intelligent M&A analysis, valuation, financial forecasting, and strategic capital decisions. By using modular knowledge cores, Sowfin organizes complex financial data into contextual intelligence graphs that power autonomous financial reasoning agents.

About Sowfin

Sowfin is an AI-driven strategic finance platform designed for enterprise CFOs, FP&A teams, and corporate development professionals. The platform helps finance leaders:

Evaluate M&A targets with comprehensive financial and strategic context
Build accurate financial forecasts powered by historical patterns and business drivers
Optimize capital structure decisions (debt, equity, and payout policies)
Conduct comparable company analysis with real-time market data
Automate valuation workflows (DCF, comparable multiples, precedent transactions)
Scenario model across business drivers and market conditions
Make data-driven capital allocation decisions

Sowfin's competitive advantage lies in its ability to contextualize financial data—understanding not just numbers, but the relationships between financial metrics, business drivers, market conditions, and strategic outcomes.

The Challenge: Fragmented Financial Intelligence

Corporate finance teams face fundamental challenges in converting raw financial data into strategic intelligence:

1. Data Fragmentation Across Systems

Financial data lives in disconnected silos with no unified context:

ERP systems (SAP, Oracle) contain operational data
FP&A tools (Anaplan, Cognos) have budget and forecast models
Capital markets data (Bloomberg, FactSet) provide market context
SEC filings (10-K, 10-Q) contain comprehensive financial history
Deal databases track past transactions and valuations
Internal systems hold proprietary business metrics and KPIs

Without unified context, financial analysis requires manual aggregation and reconciliation.

2. Complex Financial Relationships

Financial analysis requires understanding complex relationships:

How revenue drivers impact cash flow projections
How capital structure decisions affect valuation
Which comparable companies are truly comparable
How market conditions influence reasonable assumptions
How past deals inform current valuations
Which business drivers are correlated vs. coincidental

3. Manual Analysis Bottlenecks

Strategic finance requires human expertise that doesn't scale:

Building valuation models for each acquisition target
Selecting comparable companies and justifying multiples
Reconciling top-down and bottom-up forecasts
Documenting assumptions and creating sensitivity analyses
Generating reports with supporting analyses
Defending valuations to investment committees

4. Time-to-Insight Bottlenecks

Deal timelines create urgency for financial analysis:

M&A diligence requires rapid financial assessment
Capital planning cycles are fixed annually
Market conditions change faster than models can be rebuilt
Time spent on data collection reduces time on strategy
Delayed analysis can cause missed opportunities

How Sowfin Uses Knowledge Cores

Sowfin uses TrustGraph's Knowledge Cores as modular, specialized contexts for different aspects of corporate finance. Rather than a monolithic financial database, Sowfin organizes financial intelligence into multiple knowledge cores that serve as persistent memory structures for autonomous financial reasoning agents.

Architecture: Context Cores for Financial Analysis

// Sowfin organizes financial context across specialized cores
class SowfinFinancialArchitecture {
  // Company financial core: Detailed financial history and metrics
  async createCompanyFinancialCore(companyId: string) {
    const core = await tg.getKgCore(`sowfin-company-${companyId}`);
    
    // Loads company-specific financial context:
    // - Historical financial statements (10+ years)
    // - Business segment performance and drivers
    // - Capital expenditure patterns and projects
    // - Debt structure and covenant information
    // - Cash flow patterns and seasonality
    // - Management guidance and forward-looking statements
    // - Product/service metrics and unit economics
    
    return core;
  }

  // Industry and market core: Benchmarking and market context
  async createMarketContextCore(industryId: string) {
    const marketCore = await tg.getKgCore(`sowfin-market-${industryId}`);
    
    // Contains pre-loaded market context:
    // - Comparable company financials and metrics
    // - Industry peer groups and classifications
    // - Market multiples (EV/EBITDA, P/E, etc.)
    // - Industry growth rates and trends
    // - Competitive positioning frameworks
    // - Historical M&A transaction data
    // - Valuation precedent transactions
    
    return marketCore;
  }

  // Deal analysis core: M&A specific context
  async createDealAnalysisCore(dealId: string) {
    const dealCore = await tg.getKgCore(`sowfin-deal-${dealId}`);
    
    // Stores deal-specific context:
    // - Target company financial profile
    // - Buyer company strategic context
    // - Deal rationale and synergy hypotheses
    // - Financial analysis and valuation models
    // - Risk factors and sensitivities
    // - Integration planning context
    
    return dealCore;
  }

  // Capital planning core: Multi-year strategic context
  async createCapitalPlanningCore(companyId: string, planYear: number) {
    const planCore = await tg.getKgCore(`sowfin-planning-${companyId}-${planYear}`);
    
    // Stores capital planning context:
    // - Historical budget vs. actual performance
    // - Business driver assumptions and forecasts
    // - Capital allocation priorities
    // - Debt capacity and financing options
    // - Dividend and payout policies
    // - Scenario planning assumptions
    
    return planCore;
  }
}

Multi-Core Architecture

Sowfin coordinates financial reasoning across multiple specialized knowledge cores:

┌─────────────────────────────────────────────────────┐
│     Sowfin Agentic Finance Platform                 │
├─────────────────────────────────────────────────────┤
│                                                      │
│  ┌──────────────────────────────────────────────┐  │
│  │ Autonomous Financial Analysis Agents          │  │
│  │ - Valuation Agent (DCF, comparable, etc.)     │  │
│  │ - Forecasting Agent (revenue, cost, CF)       │  │
│  │ - Scenario Agent (sensitivities, cases)       │  │
│  │ - Synergy Agent (M&A integration analysis)    │  │
│  └──────────────────────────────────────────────┘  │
│           ▲           ▲            ▲                │
│    ┌──────┴─────┬────┴────┬───────┴──────┐        │
│    │            │         │              │         │
│    │            │         │              │         │
│  ┌─▼──┐    ┌───▼──┐  ┌──▼───┐    ┌─────▼──┐     │
│  │Deal│    │Company│  │Market │    │Capital  │    │
│  │Core│    │ Core  │  │ Core  │    │ Plan    │    │
│  └────┘    └───────┘  └───────┘    │ Core    │    │
│                                     └─────────┘    │
│  Each core contains RDF triples representing        │
│  financial entities, relationships, and drivers     │
│                                                      │
└─────────────────────────────────────────────────────┘

Core Type 1: Company Financial Core

Each analyzed company gets a knowledge core with comprehensive financial context:

// Load company financial history into knowledge core
async function initializeCompanyFinancialCore(
  companyId: string,
  company: CompanyProfile
) {
  // Load the company's isolated core
  await tg.loadKgCore(`sowfin-company-${companyId}`);

  // Extract financial statements into RDF triples
  const financialTriples = [];
  
  // Add historical income statements
  for (const year of company.historicalStatements.incomeStatements) {
    financialTriples.push({
      s: { v: `http://sowfin.io/companies/${companyId}/income-${year.year}`, e: true },
      p: { v: "http://sowfin.io/revenue", e: true },
      o: { v: year.revenue.toString(), e: false }
    });
    
    financialTriples.push({
      s: { v: `http://sowfin.io/companies/${companyId}/income-${year.year}`, e: true },
      p: { v: "http://sowfin.io/operatingIncome", e: true },
      o: { v: year.operatingIncome.toString(), e: false }
    });
    
    financialTriples.push({
      s: { v: `http://sowfin.io/companies/${companyId}/income-${year.year}`, e: true },
      p: { v: "http://sowfin.io/netIncome", e: true },
      o: { v: year.netIncome.toString(), e: false }
    });
  }
  
  // Add balance sheet items
  for (const year of company.historicalStatements.balanceSheets) {
    financialTriples.push({
      s: { v: `http://sowfin.io/companies/${companyId}/balance-${year.year}`, e: true },
      p: { v: "http://sowfin.io/totalAssets", e: true },
      o: { v: year.totalAssets.toString(), e: false }
    });
    
    financialTriples.push({
      s: { v: `http://sowfin.io/companies/${companyId}/balance-${year.year}`, e: true },
      p: { v: "http://sowfin.io/totalDebt", e: true },
      o: { v: year.totalDebt.toString(), e: false }
    });
    
    financialTriples.push({
      s: { v: `http://sowfin.io/companies/${companyId}/balance-${year.year}`, e: true },
      p: { v: "http://sowfin.io/shareholders-equity", e: true },
      o: { v: year.equity.toString(), e: false }
    });
  }
  
  // Add business drivers and metrics
  for (const segment of company.businessSegments) {
    financialTriples.push({
      s: { v: `http://sowfin.io/companies/${companyId}`, e: true },
      p: { v: "http://sowfin.io/hasSegment", e: true },
      o: { v: `http://sowfin.io/segments/${segment.id}`, e: true }
    });
    
    financialTriples.push({
      s: { v: `http://sowfin.io/segments/${segment.id}`, e: true },
      p: { v: "http://sowfin.io/segmentName", e: true },
      o: { v: segment.name, e: false }
    });
    
    financialTriples.push({
      s: { v: `http://sowfin.io/segments/${segment.id}`, e: true },
      p: { v: "http://sowfin.io/segmentGrowthRate", e: true },
      o: { v: segment.growthRate.toString(), e: false }
    });
  }
  
  // Ingest financial context into company core
  await tg.addDocument({
    "kg-core-id": `sowfin-company-${companyId}`,
    "content": financialTriples,
    "document-type": "rdf-triples"
  });
}

Core Type 2: Market Context Core

A shared market intelligence core provides valuation and benchmarking context:

// Create and populate market intelligence core
async function initializeMarketContextCore(industryId: string) {
  const marketCore = await tg.getKgCore(`sowfin-market-${industryId}`);
  
  // Market context includes:
  // - Comparable company multiples (current market trading)
  // - Historical M&A transaction precedents
  // - Industry valuation metrics and trends
  // - Peer group classifications and rankings
  // - Market growth rates and forecasts
  
  return marketCore;
}

// Load comparable company data into market core
async function updateComparableCompanies(
  industryId: string,
  comparables: ComparableCompany[]
) {
  const comparableTriples = [];
  
  for (const comp of comparables) {
    comparableTriples.push({
      s: { v: `http://sowfin.io/comparables/${comp.id}`, e: true },
      p: { v: "http://sowfin.io/companyName", e: true },
      o: { v: comp.name, e: false }
    });
    
    comparableTriples.push({
      s: { v: `http://sowfin.io/comparables/${comp.id}`, e: true },
      p: { v: "http://sowfin.io/marketCap", e: true },
      o: { v: comp.marketCap.toString(), e: false }
    });
    
    comparableTriples.push({
      s: { v: `http://sowfin.io/comparables/${comp.id}`, e: true },
      p: { v: "http://sowfin.io/evEbitdaMultiple", e: true },
      o: { v: comp.evEbitdaMultiple.toString(), e: false }
    });
    
    comparableTriples.push({
      s: { v: `http://sowfin.io/comparables/${comp.id}`, e: true },
      p: { v: "http://sowfin.io/peMultiple", e: true },
      o: { v: comp.peMultiple.toString(), e: false }
    });
    
    // Link to industry classification
    comparableTriples.push({
      s: { v: `http://sowfin.io/comparables/${comp.id}`, e: true },
      p: { v: "http://sowfin.io/industryId", e: true },
      o: { v: `http://sowfin.io/industries/${industryId}`, e: true }
    });
  }
  
  // Ingest into market context core
  await tg.addDocument({
    "kg-core-id": `sowfin-market-${industryId}`,
    "content": comparableTriples,
    "document-type": "rdf-triples"
  });
}

Core Type 3: Deal Analysis Core

Each deal or valuation gets its own core for storing analysis context and agent reasoning:

// Create deal-specific analysis core
async function createDealAnalysisCore(
  dealId: string,
  targetCompanyId: string,
  buyerCompanyId: string
) {
  const dealCore = await tg.getKgCore(`sowfin-deal-${dealId}`);
  
  // Load deal context: target and buyer financial profiles
  const dealTriples = [];
  
  dealTriples.push({
    s: { v: `http://sowfin.io/deals/${dealId}`, e: true },
    p: { v: "http://sowfin.io/targetCompany", e: true },
    o: { v: `http://sowfin.io/companies/${targetCompanyId}`, e: true }
  });
  
  dealTriples.push({
    s: { v: `http://sowfin.io/deals/${dealId}`, e: true },
    p: { v: "http://sowfin.io/buyerCompany", e: true },
    o: { v: `http://sowfin.io/companies/${buyerCompanyId}`, e: true }
  });
  
  dealTriples.push({
    s: { v: `http://sowfin.io/deals/${dealId}`, e: true },
    p: { v: "http://sowfin.io/dealStatus", e: true },
    o: { v: "analysis", e: false }
  });
  
  // Ingest deal context
  await tg.addDocument({
    "kg-core-id": `sowfin-deal-${dealId}`,
    "content": dealTriples,
    "document-type": "rdf-triples"
  });
  
  return dealCore;
}

// AI agent records valuation findings in deal core
async function recordValuationFindings(
  dealId: string,
  valuationAnalysis: ValuationResult
) {
  const findingTriples = [];
  
  findingTriples.push({
    s: { v: `http://sowfin.io/deals/${dealId}`, e: true },
    p: { v: "http://sowfin.io/dcfValuation", e: true },
    o: { v: valuationAnalysis.dcf.toString(), e: false }
  });
  
  findingTriples.push({
    s: { v: `http://sowfin.io/deals/${dealId}`, e: true },
    p: { v: "http://sowfin.io/comparableMultiplesValuation", e: true },
    o: { v: valuationAnalysis.comparableMultiples.toString(), e: false }
  });
  
  findingTriples.push({
    s: { v: `http://sowfin.io/deals/${dealId}`, e: true },
    p: { v: "http://sowfin.io/precedentTransactionValuation", e: true },
    o: { v: valuationAnalysis.precedentTransaction.toString(), e: false }
  });
  
  // Store valuation conclusions with confidence levels
  for (const synergy of valuationAnalysis.identifiedSynergies) {
    findingTriples.push({
      s: { v: `http://sowfin.io/deals/${dealId}`, e: true },
      p: { v: "http://sowfin.io/synergy", e: true },
      o: { v: `http://sowfin.io/synergies/${synergy.id}`, e: true }
    });
    
    findingTriples.push({
      s: { v: `http://sowfin.io/synergies/${synergy.id}`, e: true },
      p: { v: "http://sowfin.io/synergyType", e: true },
      o: { v: synergy.type, e: false }  // cost, revenue, etc.
    });
    
    findingTriples.push({
      s: { v: `http://sowfin.io/synergies/${synergy.id}`, e: true },
      p: { v: "http://sowfin.io/estimatedValue", e: true },
      o: { v: synergy.estimatedValue.toString(), e: false }
    });
  }
  
  // Persist analysis to deal core
  await tg.addDocument({
    "kg-core-id": `sowfin-deal-${dealId}`,
    "content": findingTriples,
    "document-type": "rdf-triples"
  });
}

Real-World Use Cases

Use Case 1: AI-Assisted M&A Valuation

An M&A analyst evaluates an acquisition target. The AI agent uses knowledge cores to provide comprehensive valuation context:

async function aiAssistedMAndAValuation(
  dealId: string,
  targetCompanyId: string,
  buyerCompanyId: string,
  industryId: string
) {
  // Step 1: Create deal analysis core
  await createDealAnalysisCore(dealId, targetCompanyId, buyerCompanyId);
  
  // Step 2: AI agent conducts valuation using multiple approaches
  const valuation = await tg.invokeGraphRag({
    "flow-id": "m-and-a-valuation-flow",
    "query": `
      Conduct comprehensive M&A valuation for deal: ${dealId}
      
      From target company core:
      - Historical financial performance and trends
      - Business segment profitability and growth
      - Capital intensity and reinvestment needs
      - Risk factors and business challenges
      
      From buyer company core:
      - Strategic fit with current business
      - Expected synergy opportunities
      - Integration complexity
      - Financing capacity and cost of capital
      
      From market context core:
      - Current trading multiples for comparables
      - Precedent transaction valuations
      - Industry growth trends
      - Relative competitive positioning
      
      Provide:
      1. DCF valuation with explicit assumptions
      2. Comparable company multiples analysis
      3. Precedent transaction analysis
      4. Identified cost and revenue synergies
      5. Valuation range and recommendation`
  });
  
  // Step 3: AI generates sensitivity analyses
  const sensitivities = await tg.invokeGraphRag({
    "flow-id": "m-and-a-valuation-flow",
    "query": `
      Generate sensitivity analyses for deal valuation:
      
      What is the valuation impact of:
      1. ±10% change in revenue growth assumptions
      2. ±50 bps change in WACC (discount rate)
      3. ±20% variance in identified synergies
      4. Different cost of debt scenarios
      
      Which assumptions are most critical to valuation?`
  });
  
  // Step 4: Store findings in deal core for future reference
  await recordValuationFindings(dealId, {
    dcf: valuation.dcfValue,
    comparableMultiples: valuation.comparablesValue,
    precedentTransaction: valuation.precedentValue,
    identifiedSynergies: valuation.synergies,
    sensitivities: sensitivities
  });
  
  return valuation;
}

Use Case 2: Intelligent Financial Forecasting

An FP&A analyst builds a financial forecast using AI agents that understand historical patterns and business drivers:

async function intelligentFinancialForecasting(
  companyId: string,
  planYear: number
) {
  // Load company financial history
  await tg.loadKgCore(`sowfin-company-${companyId}`);
  
  // Load or create capital planning core for this year
  const planCore = await tg.getKgCore(`sowfin-planning-${companyId}-${planYear}`);
  
  // AI agent builds forecast from historical patterns
  const forecast = await tg.invokeGraphRag({
    "flow-id": "forecasting-flow",
    "query": `
      Build financial forecast for ${planYear} using:
      
      From company financial core:
      - Historical revenue growth patterns (10 years)
      - Seasonal patterns and quarterly trends
      - Segment-level performance and margins
      - Historical CapEx patterns relative to revenue
      - Working capital cycles and trends
      - Pricing trends and mix impacts
      
      Analysis to perform:
      1. Project revenue by segment using appropriate methods:
         - Time series (Prophet, SARIMA) for stable segments
         - Driver-based (regression) for volatile segments
         - Management guidance where provided
      
      2. Project operating expenses:
         - COGS as % of revenue (historical trend)
         - Operating leverage assumptions
         - Known cost inflation factors
      
      3. Project capital requirements:
         - CapEx needed to support revenue growth
         - Working capital needs
         - Debt repayment requirements
      
      4. Calculate free cash flow and scenarios:
         - Base case using historical relationships
         - Upside case (segment growth +10%)
         - Downside case (segment growth -10%)
      
      Return detailed forecast with assumption documentation`
  });
  
  // Store forecast in capital planning core
  await tg.addDocument({
    "kg-core-id": `sowfin-planning-${companyId}-${planYear}`,
    "content": forecastToTriples(forecast),
    "document-type": "rdf-triples"
  });
  
  return forecast;
}

Use Case 3: Comparable Company Analysis with Context

Generate peer selection and valuation multiples analysis with full financial context:

async function contextualComparableAnalysis(
  targetCompanyId: string,
  industryId: string
) {
  // Load target company financial profile
  await tg.loadKgCore(`sowfin-company-${targetCompanyId}`);
  
  // Load market context with current multiples
  const marketCore = await tg.getKgCore(`sowfin-market-${industryId}`);
  
  // AI agent selects optimal comparables and applies multiples
  const analysis = await tg.invokeGraphRag({
    "flow-id": "comparable-analysis-flow",
    "query": `
      Conduct comparable company analysis for target company:
      
      From target company core:
      - Business segments and revenue mix
      - EBITDA and profit margins
      - Growth profile and trajectory
      - Capital intensity and efficiency
      - Risk profile (leverage, volatility)
      
      From market context core:
      - Available comparable companies
      - Current trading multiples (EV/EBITDA, P/E, etc.)
      - Historical multiple ranges
      - Recent transaction multiples
      
      Analysis to perform:
      1. Select optimal comparable universe:
         - Filter for similar business model and segments
         - Consider growth profile similarity
         - Assess relative size and leverage
         - Eliminate outliers with justification
      
      2. Apply valuation multiples:
         - Use median/mean multiples from comparable universe
         - Adjust for differences vs. target (premium/discount)
         - Consider trading vs. transaction multiples
         - Provide range of valuations
      
      3. Sensitivity analysis:
         - Impact of ±10% change in multiples
         - Impact of different comparable selections
      
      Return comparable analysis with:
      - Selected peer group with justification
      - Applied multiples and ranges
      - Valuation conclusion`
  });
  
  return analysis;
}

Use Case 4: Capital Structure Optimization

AI agent optimizes capital structure considering leverage, cost of capital, and strategic flexibility:

async function optimizeCapitalStructure(
  companyId: string,
  planYear: number
) {
  // Load company financial and planning cores
  await tg.loadKgCore(`sowfin-company-${companyId}`);
  const planCore = await tg.getKgCore(`sowfin-planning-${companyId}-${planYear}`);
  
  // AI agent analyzes capital structure optimization
  const optimization = await tg.invokeGraphRag({
    "flow-id": "capital-structure-flow",
    "query": `
      Analyze and optimize capital structure for ${planYear}:
      
      From company financial core:
      - Current debt levels and costs
      - Interest coverage ratios
      - Rating agency constraints
      - Historical debt capacity
      - Cash flow generation capability
      
      From capital planning core:
      - Projected cash flows
      - Capital investment requirements
      - Covenant constraints
      - Refinancing needs and maturity schedule
      
      Analysis to perform:
      1. Calculate optimal leverage ratio:
         - Target leverage based on peer group norms
         - Consider industry and company-specific factors
         - Evaluate risk/return trade-offs
      
      2. Cost of capital analysis:
         - Current cost of debt vs. market rates
         - Implied cost of equity (CAPM)
         - Weighted average cost of capital
         - Impact of different leverage scenarios
      
      3. Capital allocation recommendations:
         - Debt capacity for acquisitions or investments
         - Dividend vs. share repurchase optimization
         - Debt paydown requirements
         - Strategic flexibility needs
      
      Return optimization analysis with:
      - Recommended capital structure
      - Financing plan for ${planYear}
      - Sensitivity to economic scenarios`
  });
  
  return optimization;
}

Benefits of Knowledge Cores for Sowfin

1. Contextual Financial Intelligence

Knowledge cores enable agents to reason about complex financial relationships:

// Agents can understand how financial metrics relate
// without requiring explicit SQL queries or manual data assembly

// Example: Revenue forecast considers:
// - Historical growth trends (from company core)
// - Segment-specific drivers (from company core)
// - Market growth rates (from market core)
// - Management guidance (from company core)
// - Economic indicators (from market core)

// All relationships are captured in RDF triples,
// making them accessible to agent reasoning

2. Persistent Deal Memory

Each deal analysis is preserved as a knowledge core, enabling:

// Future agents can access previous valuations
// to understand:
// - How previous assessments aged vs. outcomes
// - Historical synergy estimates vs. realization
// - Discount rates used in past models
// - Comparable multiples evolution over time

3. Automated Scenario Analysis

Agents can efficiently generate sensitivity analyses and scenarios:

// Rather than rebuilding models, agents query knowledge cores
// to understand impacts of key assumption changes

// Scenarios stored in cores for comparison analysis:
// - Base case (management guidance)
// - Bull case (+10% revenue growth)
// - Bear case (-10% revenue growth)
// - Stressed case (recession scenario)

// All scenarios accessible for executive review

4. Comparable Selection Intelligence

Market context cores enable intelligent peer selection:

// Knowledge cores capture:
// - Comparable company financials and metrics
// - Valuation multiples and trends
// - Business model similarities and differences
// - Relative positioning (growth, profitability, leverage)

// Agents can reason about which comparables are most relevant
// rather than requiring manual selection

5. Financial Forecasting with Pattern Recognition

Historical data in company cores enables intelligent forecasting:

// Knowledge cores preserve:
// - Historical revenue growth patterns
// - Seasonal variation in revenues and expenses
// - Margin trends and drivers
// - Capital expenditure patterns
// - Working capital dynamics

// Agents can recognize patterns and apply appropriate
// forecasting methodologies automatically

Technical Implementation

Multi-Agent Orchestration Across Cores

class SowfinAgenticOrchestration {
  async executeM&AAnalysisWorkflow(deal: Deal) {
    // Create isolated deal core
    const dealCore = await tg.getKgCore(`sowfin-deal-${deal.id}`);
    
    // Multiple specialized agents working on deal
    const [
      valuationAnalysis,
      synergyAnalysis,
      riskAnalysis,
      integrationPlanning
    ] = await Promise.all([
      // Agent 1: Valuation specialist
      this.runValuationAgent(deal),
      
      // Agent 2: Synergy analyst
      this.runSynergyAgent(deal),
      
      // Agent 3: Risk specialist
      this.runRiskAnalysisAgent(deal),
      
      // Agent 4: Integration planner
      this.runIntegrationAgent(deal)
    ]);
    
    // All agents can reference the same deal core
    // and read each other's findings (written to core)
    return {
      valuation: valuationAnalysis,
      synergies: synergyAnalysis,
      risks: riskAnalysis,
      integration: integrationPlanning
    };
  }

  async runValuationAgent(deal: Deal) {
    // Valuation agent queries across cores
    const results = await tg.invokeGraphRag({
      "flow-id": "valuation-agent-flow",
      "query": "Perform comprehensive DCF and multiples valuation"
    });
    
    // Write findings to deal core
    await tg.addDocument({
      "kg-core-id": `sowfin-deal-${deal.id}`,
      "content": resultsToTriples(results),
      "document-type": "rdf-triples"
    });
    
    return results;
  }
}

Federated Queries Across Company Cores

// Query multiple companies for M&A comparison
async function compareBidderAndTarget(
  targetCompanyId: string,
  buyerCompanyId: string,
  industryId: string
) {
  // Load both company cores
  await tg.loadKgCore(`sowfin-company-${targetCompanyId}`);
  
  // Query across cores to understand fit
  const comparison = await tg.invokeGraphRag({
    "flow-id": "m-and-a-comparison-flow",
    "query": `
      Compare buyer and target companies:
      
      Buyer company analysis:
      - Revenue and growth profile
      - Profitability and margin trends
      - Current leverage and debt capacity
      - Historical M&A track record and synergy realization
      - Strategic gaps and growth priorities
      
      Target company analysis:
      - Revenue and growth profile
      - Business segments and concentration
      - Profitability and margin trends
      - Management quality and retention risk
      - Customer concentration and stickiness
      
      Strategic fit analysis:
      - Synergy opportunities (cost and revenue)
      - Integration complexity
      - Cultural fit and talent risks
      - Regulatory and competition concerns
      - Strategic rationale strength
      
      Return comprehensive comparison with:
      - Deal attractiveness assessment
      - Key risks and mitigants
      - Integration planning framework`
  });
  
  return comparison;
}

Results and Impact

Operational Benefits

Faster Analysis: AI agents reduce valuation timeline from weeks to days
More Rigorous: Multiple methodologies applied consistently (DCF, comparable multiples, precedent transactions)
Better Documentation: All assumptions and reasoning preserved in knowledge cores
Improved Consistency: Historical precedent and patterns inform new analyses
Scenario-Ready: Sensitivity analyses automated and easily refreshed

Technical Advantages

Data Integration: Financial data from multiple sources unified in knowledge cores
Contextual Reasoning: Agents understand relationships between financial metrics
Persistent Memory: Deal analyses preserved for compliance and learning
Modular Design: Company, market, and deal cores can be composed flexibly
Scalable Intelligence: Agents can analyze multiple deals in parallel

Best Practices from Sowfin

Core-per-Company: Each analyzed company gets dedicated knowledge core with financial history
Shared Market Context: Market core provides valuation benchmarks shared across all deals
Deal-Specific Analysis: Each deal gets isolated core for analysis and agent reasoning
Multi-Agent Architecture: Specialized agents (valuation, synergy, risk, integration) reason across cores
Federated Queries: Platform enables comparative analysis across multiple companies and deals
Historical Preservation: Completed deal analyses archived as knowledge cores for compliance and learning
Assumption Transparency: All forecast and valuation assumptions explicitly captured in triples

Conclusion

Sowfin's use of TrustGraph Knowledge Cores demonstrates how modular, specialized graph instances power intelligent corporate finance:

✅ Contextual financial intelligence that understands relationships between metrics
✅ Agentic reasoning across multiple specialized analyses
✅ Persistent deal memory for compliance and learning
✅ Flexible composition of company, market, and deal contexts
✅ Scalable M&A analysis from data integration to valuation and integration planning
✅ Enterprise-grade automation with human oversight and validation

By leveraging knowledge cores, Sowfin delivers AI-powered corporate finance with the contextual intelligence, analytical rigor, and human control required for strategic capital decisions.

Related Concepts

Knowledge Cores as Modular Memory - Deep dive into knowledge cores
GraphRAG - Graph-enhanced retrieval and generation for financial analysis
Structured Data in Knowledge Graphs - Working with financial data types
Agent Tool Configuration - Configuring specialized financial analysis agents
RDF for Enterprise Data - Semantic representation of financial relationships