# fundos.vantedgeai.com/llms.txt
# Always current — this file is served live from the running deployment.
# Change history: https://github.com/8vdx1/FundOS/blob/main/CHANGELOG.md

# FundOS by VantedgeAI

Investor capital calls show supplied reasons and dated payment history. In VI,
Manage Investment lets each receipt identify the capital call it pays; after
sync, FundOS shows requested, paid and unpaid amounts separately.

PC monthly reporting may use a separately enabled per-fund bank-statement cash source. Administrators enter original-currency balances with an actual source date and uploaded evidence. Currencies are never converted or summed together. Non-month-end dates and incomplete historical backfill are visible warnings; missing source cash is unavailable, not substituted with book cash. Reviewed reports freeze the exact evidence version; corrections preserve signed/issued history. No bank feed, ledger, NAV, planner-cash or reconciliation change occurs.

PC expense-category LPA checks show draft rows with payer ticks automatically
without page refresh; humans review and save terms directly in the table.
Category checks request a typed Gemini status/category/evidence schema, preserve outer JSON and use provider-default output limits with at most two total billed format/envelope attempts; truncation/refusal stops immediately, and evidence checks and human review remain mandatory even when local providers enforce only JSON-object mode.
Ticks mean pays and reflect current conditional eligibility, with per-role LPA evidence available for review.
An unmatched LPA quote remains visible as a per-category warning rather than hiding all suggestions. Human approval of that category requires a review note; its evidence stays marked unverified.
Standing expense rules may be approved before investor onboarding; actual expense allocation still requires resolved investor roles and commitments for its calculation date.
PC Expenses also expands each expense into its existing investor allocation, with exact cents and a per-expense total alongside the all-expenses investor rollup. This read-only view preserves reviewed snapshots and the selected recognition period; missing allocations are not treated as exemptions.
The PC expense form selects saved reviewed category versions and displays evaluated payer ticks for the full bill date, not an implicit month-start. Conditional results are not manual overrides; explicit bill-only overrides require a reason and do not change the category. PC budget fees remain in their scheduled month when the view horizon changes.
PC Budget includes recorded expense recognition months in its month, quarter, year and edit views, even without a first-close date or planned lines, preserving the future planning range without creating budget amounts or changing accounting dates.
PC Budget and Fund Admin Investors share one read-only Plan capital call editor for current and future months using reconciled FundOS cash, retained cash, and selected unpaid calls. For the month in progress, a warning asks users to review/edit remaining funding needs; full-month budgets are not automatically prorated or reduced by actual expenses. Current-month eligibility is evaluated today, and calls may be due today through month-end. Current-month fee funding may be reduced while preserving computed investor fee weights; fee terms and accounting do not change. Budget rows prefill editable lines; users may adjust/remove them or add investment and reviewed expense-category lines without changing the saved budget. Open plan buttons carry the edited plan between both views. Each line shows cost, editable existing cash and net call, preserving its payer rules and per-investor net fees. Cash differing from the available allowance needs explicit acknowledgement of unused cash or reduced retention; cash above recorded funds or a line's remaining cost is invalid. Investor-by-line breakdowns show receipts and cash applied once. After explicit administrator review, Create Vantedge drafts durably hands the exact amounts to VI for review; it does not place Outlook drafts, send emails, issue FundOS calls or post accounting. Changed evidence requires a fresh preview; unsupported allocations and missing cash evidence block the recommendation.

> FundOS is the continuously current operating system for private equity,
> private credit, venture capital and hedge fund managers. It connects books,
> LP records, portfolio data, documents and workflows so AI agents reconcile,
> monitor and prepare fund operations against current data. Every consequential
> action remains subject to human approval.
>
> FundOS resolves entities, source priority, fund economics, obligations and
> approvals into one governed operating context. Answers and prepared actions
> stay tied to their source records. If required evidence is unavailable, the
> control remains open rather than becoming a pass.
> Investor earnings splits conserve cents, including losses. Fee posting refuses
> overlapping monthly and quarterly charges; corrections retain prior entries.
>
> Around that compliance core, FundOS connects fund operations, investor
> reporting, diligence and audit preparation in one system: deal sourcing,
> fundraising, transactions, risk, CFO / accounting, investor relations,
> audit, and trading.
>
> FundOS is the product, built by VantedgeAI, Inc. The product home is
> https://fundos.vantedgeai.com. Kela's company overview is at https://kela.com;
> both hosts continue to serve the same authenticated application and APIs.

## FundOS modules

Every module FundOS ships is listed at /fundos/capabilities — grouped by function,
showing which ones a given workspace has enabled and which are available on request.
A workspace only sees enabled modules in its nav, so that page is the canonical
human-facing answer to "what can FundOS do?" (the machine-facing answers are
/.well-known/fundos-modules.json and /api/v1/tools).

- Compliance Program (Rule 206(4)-7) at /fundos/compliance/program: the CCO's system of record — versioned compliance manual, risk register, controls, testing, findings, and an annual review that snapshots and finalizes immutably. 25 evidence collectors test controls against the workspace's ACTUAL books (NAV release timeliness and preparer/reviewer segregation, capital-account roll-forward integrity, mark staleness, capital-call notices, sanctions re-screening currency for investors AND their beneficial owners, adjudication of possible matches, beneficial-owner completeness, restricted-list enforcement against the live position book, pre-clearance turnaround, filing deadlines). A control test has FOUR outcomes — passed/exception/no_data/error — and no_data is NOT a pass: a control that could not be tested is reported untested and counts as a gap in the annual review's own coverage. Includes: PROCEDURES (/fundos/compliance/program/procedures) — reads the firm's OWN policies-and-procedures manual and proposes each testable procedure with the manual's verbatim words and section reference, and confirming one materialises a real control tested through the same engine; the AI may only propose a MAPPING onto an already-registered evidence collector, never author a check, and every proposal is corroborated against that collector's own vocabulary so an unsupported one is left UNMAPPED rather than bound to the nearest check (an unmapped procedure becomes a manual control reported as untested, never as passing) — manual coverage and program coverage are published side by side because they answer different questions; side-letter + LPA obligation extraction and monitoring with MFN benchmarking (AI-proposed clauses stay unconfirmed and drive nothing until a human confirms them against the stored verbatim contract text); Code of Ethics disclosures with a Rule 206(4)-5 pay-to-play screen that cross-references political contributions against the firm's own LP register for government-entity time-out exposure; attestation campaigns; Marketing Rule (206(4)-1) review across 14 checks that also RECONCILES every performance claim against the fund's actual NAV runs and capital accounts (match / mismatch / unverifiable — unverifiable is never rendered as verified); an SEC examination binder that answers the standard document request list and names what the firm cannot produce; and read-only Evidence Packs (/fundos/compliance/program/evidence-pack/<subject_type>/<id>) that assemble policy, citation, source records, frozen evidence, human reviewer/timestamp and gaps for the specific control, finding, obligation, marketing review, attestation, CoE disclosure, exam binder or HF pre-trade check under review. The seeded program is regime CONTENT rather than hardcoded machinery — the default pack is a US private-fund adviser (Rule 206(4)-7) and a SEBI-registered AMC pack also ships for Indian mutual funds, with the same spine and its own policies, risks, controls and page labels; a control is wired to an automated collector only where that collector can honestly run for the regime, so each pack publishes how many of its controls are automated versus attested by a human, and all seeded policy text is starter drafting for the firm's counsel rather than legal advice
- Compliance OS: KYC/AML pipeline with Gemini name screens, regulatory filing deadlines (Form ADV/PF/13F/AIFMD/GDPR ROPA/CTA BOI), restricted-securities + pre-clearance queue, obligations register, Compliance Dashboard. The restricted list is enforced as a CONTROL, not stored as a policy: every order path (order ticket, order API, rebalance approval, broker fill import, broker connectivity test) and the Code of Ethics personal-trade screen go through one resolver that reads BOTH restricted lists, matches on ticker/ISIN/CUSIP/company name, honours the effective-expiry window (so a personal trade is screened as of ITS trade date, not today), is side-aware, and FAILS CLOSED — an order whose check could not run is stopped, because an order that has not been checked has not cleared. Every screen writes an immutable record (including the ones that clear and the blocked orders that are never persisted), readable at /fundos/compliance/trade/checks with CSV export and a Bearer twin at GET /api/v1/fundos/compliance/trade/checks, and folded into the SEC exam binder — a populated list with no checks behind it reports PARTIAL, never READY. Adding or lifting a restriction is admin-only and recorded with actor and timestamp. For funds that trade away from FundOS and reconcile, the control is detection rather than prevention and is explicit about it: each fill is screened as of its own trade date, a restricted one is booked BLOCKED (never APPROVED) and opens a critical exception with an SLA, and the fund's own post-trade rules re-run automatically on every fill import plus nightly — so a restriction added today to a name held for a month is still caught. A fund that has adopted no rules is reported 'not configured', never 'clean'. Adviser-tier layer (Adviser Profile at /fundos/compliance/profile): Registered / Exempt Reporting Adviser (ERA) / State-registered — ERA checklist (Form ADV Part 1A annual updating amendment tracked at fiscal-year-end + 90 days, state notice filings, ERA obligations), Form ADV draft generation, and a deterministic AUM registration-trigger watcher vs the $150M private fund adviser exemption ceiling (surfaces on the GP + Compliance dashboards and the Fund Intelligence brief). Drafts + reminds only — not legal advice; every regulatory item is flagged "verify with counsel"
- FundOS Copilot: the chat drawer on every FundOS page. GROUNDED — every number and proper noun about your workspace (LP names, commitments, fund and per-LP NAV, ownership, TVPI/DPI/RVPI/IRR, capital accounts, outstanding capital calls, document titles) comes from a read-only tool call against the fund-admin read layer, with a link to the screen it came from; when no tool returns the fact, the Copilot says it cannot find it instead of inventing one. It can tell you a fund you named does not exist. It also will not COMPUTE a valuation it was not given — an ownership percentage times a fund's NAV is not an investor's NAV — and a fund with no released, four-eyes-signed NAV is reported as having no residual value yet rather than a multiple computed against zero, so a chat answer cannot disagree with the Performance page or the ILPA report the LP already received. Tool calls are recorded as an AgentRun so the evidence behind any figure is auditable.
- Fund Graph: the networked-knowledge layer across all modules — one unified Person identity per human (deal contacts + LP contacts + introducer network auto-unified by email at /fundos/people), Connections/backlinks panels on deal/LP/person pages with human-confirmed "mentioned with" suggestions mined from notes and meeting summaries (exact-name matching, no LLM), living-brief entity memory for deals/companies/people (LP-style, MNPI-stripped for agents), an interactive graph lens at /fundos/graph (hover-spotlight, focus/ego mode with back-button trail, search-fly), and warm-path routing ("who can get us to this LP?" — ranked intro routes on the LP page and via fundos_find_paths, hub-discounted so a broad connector does not outrank a close one, with unconfirmed hops labelled; it routes between records you already have and discovers nothing external). Agents read it via fundos_get_backlinks / fundos_get_graph / fundos_find_paths / fundos_get_entity_memory.
- Manager Reports (LP side, for allocators holding external funds) at /fundos/cfo/manager-recon: reconciles each manager's quarterly report against the allocator's own recorded terms and dated cash flows — paid-in, distributions, TVPI/DPI/net IRR recomputed on the allocator's own flows, management fee (including the post-investment-period basis, fee discounts and transaction-fee offsets), fair share of the fund, carried interest against the waterfall on the recorded hurdle/catch-up/carry, expense cap, and a NAV roll-forward whose residual is money that left the account under no stated heading (match / mismatch / unverifiable — unverifiable is never a pass); a portfolio roll-up with one TVPI/IRR and a quarter-close checklist; a LOOK-THROUGH that consolidates every fund's schedule of investments, weighted by the allocator's share, with its own direct and co-invest holdings, and flags the same company marked differently by two holders; company stage/sector/country classification proposed by AI only from the workspace's own documents (never the web) and confirmed by a person; and MANDATE RULES written in plain English ("no single company above 25% of the fund", "buyout companies only") that AI turns into a formula over a fixed metric list (parsed against an allow-list, never executed as code), an attribute mandate or a compliance-rule template, previewed on today's data and saved by an admin — a breach that rests on an unconfirmed classification is reported as a PROBABLE breach until someone confirms it. BENCHMARKING against public markets: each external fund is measured against an index the allocator chooses — KS-PME (above 1 beat the index), direct alpha (the yearly margin) and the index-equivalent value (what the same calls would be worth in the index), charted beside every reported NAV, plus a portfolio PME that states how many funds it covers; index levels are uploaded per workspace (licensed series stay in that workspace) and a flow the index cannot price within 35 days is reported unverifiable rather than filled with an assumed return; pme, direct_alpha_pct, years_invested and portfolio_pme are mandate-rule metrics (e.g. "pme >= 0.9 or years_invested < 5"). The reviewer workflow: an admin corrects any figure the AI missed or misread (the AI's reading is kept beside it; correcting a confirmed reading reopens it); scanned image-only reports are transcribed and read, labelled so the reviewer checks figures against the original; cash flows import in bulk from a CSV (previewed first, duplicates skipped) or from the deal's investment records; and a DRAFT QUERY TO THE MANAGER lists every mismatch with its report line and the allocator's evidence, as text or a Word draft — built deterministically, never sent by FundOS. Every AI-read figure must quote its report line or it is not used; nothing posts to the GL. Web UI only — no MCP tool or REST endpoint exposes it yet
- Fund Intelligence: proactive AI monitoring — daily brief at /fundos/monitoring/, 3-module pipeline (Compliance OS, LP Portal, CFO Center), Monitor → Investigate → Judge → Publish, dual-judge quality gate, severity-tiered findings (CRITICAL/HIGH/MEDIUM/LOW), snooze + mark-resolved actions, memory of prior flags
- AI FDE (Field Deployment Engineer): hybrid fund onboarding agent — upload PPM/pitch deck for instant profile extraction (Gemini multimodal), OR complete a 30-question async Q&A interview; Fund Profile extraction, module recommendation, one-click configuration; admin dashboard at /fundos/fde/; client page at /onboard/<token>
- Deal CRM: pipeline kanban, deal screening (Agent B), inbound pitch-deck screening (email a PDF/PPTX deck to your workspace address — the agent extracts the deck text, screens it against your configured investment thesis at /fundos/crm/thesis, and proposes a scored deal with a memo attached), one-click interest follow-ups (a founder outreach draft that is never sent, a proposed intro-call hold on your connected calendars, and a pre-call brief — all filed on the deal card, all human-approved), inbound email triage, Google Calendar sync, post-meeting summaries, CRM Copilot (natural-language pipeline queries like "deals stuck in diligence 30+ days", a "what your agents did while you were away" activity feed, and paste-to-pipeline quick import)
- Portfolio & Pipeline News: a default-on, cron-refreshed news feed for the companies in the deal book (active + pipeline deals) — per-company headlines on the GP dashboard + a grouped feed at /fundos/news/ (1 latest + "N more", newest first, link-out). Finnhub for tickered names, free Google News RSS for private companies; an LLM relevance filter uses each company's context + homepage description (fetched from its domain) to drop same-name noise. Per-org admin toggle at /fundos/news/settings disables or re-enables the feed; env NEWS_FEED_ENABLED = global force-on.
- LP CRM: LP relationship tracking, meeting summaries, fundraising autopilot (Agent A), per-LP data rooms, fundraising pipeline kanban (8 stages), buying-intent signals, AI outreach drafting, trackable doc shares, analytics dashboard, IR communications (segmented LP distribution lists, email campaigns with AI-drafted bodies, per-LP open/click tracking that auto-logs signals; native SMTP or SendGrid/Mailchimp), prospecting connectors (Apollo.io people-search + CSV import of Dakota/LinkedIn exports into a review queue), LP Intent Radar (every LP ranked by a composite buying-intent score with human "why now" reasons drawn from owned first-party engagement — data-room views, email opens/clicks, meetings — plus one-click outreach drafting; no third-party ad de-anonymization), promised follow-ups ("come back to us in the fall" stored as a date with the LP's own words, resolved against when it was said, surfaced when the window opens and auto-closed once you make contact — due promises outrank the intent score, since an LP who made one has usually gone quiet), CRM Copilot (ask your LPs in plain English — "family offices I haven't contacted in 21 days", "overdue follow-ups", "soft commits over $5M" — plus the shared agent activity feed and paste-to-pipeline quick import)
- VDR: secure data rooms, diligence agent (Agent C), BYOD document access via MCP connectors. Documents expose FULL extracted text over MCP (fetch / fetch_many — read up to 50 documents' text in one call) so an agent can write memos grounded in the actual documents, not just metadata. Per-document read engagement via the get_document_activity MCP tool — time spent, read sessions, unique readers, pages read, last read — distinguishing a document that was merely opened from one actually read
- Transaction Manager: term sheets, closing coordination, counterparty extraction (Agent D), CP/task pack auto-seeding
- Pricer: IRR/MOIC/WAL modeling, European waterfall, sensitivity tables, and a typed loan book (with fair-value marks, vintage/cohort analytics — cumulative charge-off and 60+ DPD by origination year — and vintage development curves charting each cohort's cumulative charge-off, 60+ DPD, and pool factor across the whole tape history at /fundos/pricer/vintages) — upload monthly loan tapes (CSV/XLSX) through a human-confirmed column-mapping preview (mappings remembered per servicer), get pool analytics computed from the tape (delinquency buckets, WAC, WAL, 60+ DPD %, obligor/sector/geography concentrations, annualized CDR/CPR from month-over-month transitions) plus a roll-forward diff (new/exited/balance-changed/delinquency-rolled loans) previewed before any row commits
- Risk Intelligence: covenant monitoring, breach simulation, risk agent (Agent F), portfolio-wide compliance scan; Credit Facilities workspace (warehouse/ABL/subscription/NAV lines) with a deterministic borrowing-base engine — data-driven eligibility rules, advance-rate tiers, concentration limits whose excess is DEDUCTED, draw/paydown ledger, collateral pledges (one pledge per loan org-wide — the double-pledge guard is a DB constraint; SPV-style pledged-only mode), fair-value marks counted in the base (writedown reported separately), availability vs commitment with code-verified foot checks — plus computed covenants (delinquency %, CDR, CPR, WAL, WAC, OC ratio, utilization, max concentration derived nightly from the loan book — no hand-keyed values), officer compliance certificates (unknown tests render NO DATA, never assumed passing), one-click lender reporting packs (borrowing-base certificate + compliance certificate + stratifications as XLSX/ZIP; optionally auto-filed into a facility-bound VDR room under "Lender Reporting/"), credit-agreement digitization that feeds monitoring (extracted covenants/eligibility/advance rates become monitored tests + draft facilities through a human-confirmed preview), a term-sheet stress test (a counterparty's proposed eligibility/advance/concentration terms run through the borrowing-base engine against the live book — breached limits, per-rule impact, availability vs the requested draw, unmappable criteria listed as NOT tested — with an optional display-only AI counter draft), servicer remittance reconciliation (collection reports ingested like tapes and reconciled per loan: balance roll, current-tape match, missing/unknown loans, expected cash — breaks land in the Exception Inbox), and a Treasury view at /fundos/treasury (facility outstandings + undrawn availability today; read-only Plaid bank balances once configured — FundOS never initiates payments)
- CIM Builder: AI-generated investment memoranda, per-section Regenerate + Suggest edits, three templates (standard, teaser, one-pager)
- Investor Portal: LP commitments, capital calls, ILPA notices, reminder ladder (Agent E)
- CFO Center: fund accounting, GL sync, P&L (MTD/QTD/YTD realized + unrealized), flux/variance analysis (line-by-line P&L actual vs prior period vs budget, with an AI driver sentence per material line — read-only commentary, the CFO Flux agent), the board-ready Variance Pack (KPI tiles with per-tile provenance, a gross-to-net bridge footed in code, one-line management message; publishes as XLSX + PDF + self-contained HTML into the fund's reporting room), Reporting Style (per-workspace/per-fund standing materiality, always-comment lines, tile order and house tone), budget baseline per fund/period, period close workflow (month/quarter/year-end with LP waterfall allocation), per-LP deal terms (hurdle/carry overrides), risk metrics (Sharpe ratio, fund leverage, bond DV01), P&L movers attribution, Fund vs Benchmark chart (SPY/QQQ), K-1 tax docs, Auditor Data Room, Audit Pack, SEC Exam Readiness, Valuation Support; daily NAV accrual engine (management-fee daily accrual ledger with HF 252-day/PE 365-day convention, crystallization workflow, GL journal entry posting)
- Fund Administration: AI-native fund-admin spine — deterministic NAV engine (positions × independently-sourced price + cash − liabilities − accruals, per fund account), independent pricing hierarchy (sources + dated quotes with staleness flag), tolerance/validation gate + exception queue, independent reconciliation (book vs custodian/PB tie-out with a break/exception queue + an opt-in per-fund gate that blocks NAV release until the book reconciles clean), four-eyes NAV sign-off with enforced segregation of duties (preparer ≠ reviewer; open critical exceptions block release), per-LP capital-account ledger with real management + incentive fees (reusing the daily-accrual + waterfall engines, honoring HWM/hurdle + per-LP terms) + clawback exposure + PCAP statements (HTML/XLSX); a transfer-agency investor register (subscriptions/redemptions/transfers + units per share class); a distribution waterfall engine (split a fund cash distribution through the European waterfall — return of capital → preferred → GP catch-up → carry — and allocate per-LP, draft → human-issued → GL-posted); a deal-by-deal (American) waterfall (per-deal carry on each realized investment + fund-level clawback exposure vs the whole-fund European entitlement); distribution TAX CHARACTER (every distribution reads two ways — the waterfall counts it against capital to drive the hurdle and carry, while the accounting split separates return of capital from income because the LP is taxed on the income portion; character is derived from per-deal realized economics net of prior issued distributions, carried into the capital account, the K-1 and all six LP statements, and a split that does not foot to the total falls back to the single total line so a statement never publishes arithmetic that does not add up); LPA-driven equalization (subsequent-close investors equalized on the terms actually on file, per-asset-class rates, one-click draft booking); a GP carry ledger (the waterfall's GP leg lands in a real account against is_gp carry recipients instead of evaporating); GAAP or IFRS financial statements (assets & liabilities, operations, changes in partners' capital, schedule of investments, statement of cash flows, ASC 946 financial highlights — expense/NII/incentive ratios + total return, an ASC 820 / IFRS 13 fair-value hierarchy (Level 1/2/3), and disclosure footnotes) tied out to the released NAV; credit-fund loan accounting (interest accrual cash-pay/PIK, amortization schedules, loss provisioning); fund-expense allocation (apportion fund-level expenses across LPs pro-rata by commitment or equally, with an organizational-expense cap and management-fee-offset reporting); commitment & uncalled-capital tracking (per-LP + fund committed/called/contributed, uncalled dry powder, called-but-unpaid outstanding, recallable distribution capacity); a management-fee engine (stepped rates for investment-period step-downs, committed/invested/NAV basis, per-LP side-letter discounts, period fee per LP); a consolidated per-LP investor reporting pack (one report bundling the LP's capital account, performance, commitments, management fee, and allocated expenses — printable + XLSX); fund & per-LP performance metrics (TVPI / DPI / IRR — paid-in, distributions, released-NAV residual value, money-weighted XIRR); Scenario Lab (/fundos/fund-admin/scenario-lab), a read-only mark-only what-if page that moves one company FMV from the released NAV baseline and exposes changed values only under scenario_* fields; regulatory data packs (Form PF / AIFMD Annex IV / FATCA-CRS assembled from the released NAV + LP register, draft → human-reviewed → marked filed; e-filing is a downstream gate). "AI prepares, human signs" — NAV-path math is deterministic code, never an LLM. Existing-fund onboarding: an "Onboard a fund" wizard (/fundos/fund-admin/onboard) sequences discovery → history imports → shadow NAV → reconciliation → human-confirmed cut-over; read-only QuickBooks Online + Xero GL connectors pull the chart of accounts + journals behind the fund's gl_provider into NAV cash/liabilities; and a Carta/AngelList/Sydecar cap-table import brings LPs + commitments into the investor register — so an established fund with an incumbent administrator adopts FundOS without a rip-and-replace
- Syndication Engine: allocation matrix, KYC, funds flow management
- Exception Inbox: unified cross-module alert inbox at /fundos/exceptions/; ingests from DTCC (settlement fails, confirm breaks, HF risk alerts), Compliance (covenant breaches, risk alerts, filing deadlines, KYC gaps), OMS (rejected orders, pre-trade blocks), FIX (session outages); severity-tiered SLA clock (critical=4h, high=24h, medium=72h, low=7d); MCP tools exceptions_list/exceptions_get/exceptions_update; CLI fundos exceptions ls|show|ack|resolve|suppress|sweep; webhooks exception.created/exception.resolved/exception.sla_breached/exception.agent_resolved; cron sweep every 15 min on weekdays
- Agent Resolution Playbooks (Run 2): step-DSL playbook engine at /fundos/exceptions/playbooks/; 5 global seed playbooks (unaffirmed_trade, covenant_breach, filing_due, import_failure, kyc_gap); modes auto_resolve/draft_only/triage_only; allowlisted tools only (dtcc_get_trade_status, dtcc_lookup_ssi, compliance_check_covenant, llm_draft, resolve, escalate + 5 more); per-org daily cap; PlaybookRun audit log with step-by-step credits/tokens; AI drafts (Gemini Flash) attached for human review; MCP tools playbooks_list/playbooks_configure/exception_run_playbook; webhook exception.agent_resolved
- Model Portfolios + Rebalancing (Run 3): target-weight model definitions (name, benchmark, weights in bps, per-ticker band/min-trade-size); fund account assignments with cash buffer; drift detection engine (current vs target weight comparison, band breach logic); rebalance proposal lifecycle (proposed → approved → orders_created | cancelled); cash-flow mode (inflow/outflow distributes pro-rata); proposal approval creates OMS orders through pre-trade compliance; auto-drift-scan across all active assignments; exception inbox wiring (model_drift); MCP tools oms_models_list/oms_models_get/oms_models_create/oms_rebalance_propose/oms_rebalance_approve; CLI fundos rebalance models|run|show|approve; web UI at /fundos/oms/models and /fundos/oms/proposals; gated by `rebalancing` module flag
- Admin-TB Shadow Reconciliation (Run 8): for funds that keep an external administrator (book_role=shadow) — FundOS computes a daily internal trial balance from the double-entry GL and reconciles it per-account against the administrator's delivered TB (monthly Excel/CSV/PDF) through a human-confirmed AI-proposed chart-of-accounts map at /fundos/fund-admin/<fund>/admin-tb; breaks land in the exceptions inbox as tb_break with deterministic classification (accrual_timing / missing_expense / fx_translation / mapping_gap / unexplained), re-runs re-trigger instead of duplicating, ties auto-resolve; roll-forward proof shows both books' net assets side by side; go-live path seeds a balanced DRAFT opening journal entry from the confirmed admin TB (four-eyes posts); daily DR=CR integrity cron + gl.integrity_failure webhook; TB export XLSX/CSV; MCP tools fundos_gl_trial_balance/fundos_run_admin_tb_rec; CLI fundos gl tb|rec; per-fund opt-in (admin_tb_rec_enabled), ships dark

The workspace's fund strategy (PE / Private Credit / Structured Credit / VC /
Hedge Fund / Multi-Strat) shapes the whole UI: module preset, terminology
(Borrowers vs Positions vs Portfolio Companies), covenant catalog, and which
performance metrics render — hedge-fund and structured-credit workspaces hide
closed-end multiples (TVPI/DPI/MOIC) that don't apply to them. Admins
fine-tune everything per workspace at /billing/workspace-profile; the CFO
dashboard API returns a `metrics_visible` list agents should respect.

## Trading vertical (per-org switcher)

- Order Management System: order blotter, pre-trade compliance (restricted list, short locates, position limits), Replace/Cancel/Broker Ticket flows. Supports 8 instrument types: Equity, ETF, Bond, High Yield Bond, Preferred, Option, Future, Swap — each with instrument-specific fields (CUSIP/coupon/maturity for bonds; strike/expiry for options; contract/multiplier for futures; notional/fixed rate for swaps)
- Position book: real-time Finnhub prices, WAC accounting, unrealized/realized P&L, gross/net exposure. Click any position to expand per-lot detail with short-term / long-term classification and unrealized gain/loss
- IBOR (Investment Book of Record, Generation 3 "Live Extract"): an append-only event ledger (ibor_events) from which positions and cash are DERIVED on request rather than stored and mutated. On the positions blotter (/fundos/oms/positions) a State selector shows Live (trade-date), Settled, or +Open-orders (what-if) views, and a Forward Cash Ladder projects per-currency cash over the next 30 days — rolling pending trade settlements, LP distributions, capital calls and corporate actions — with a "Deployable today" figure (lowest projected balance = idle cash you can deploy now without a funding gap). Derived-vs-stored parity is proven at Admin → IBOR ledger (/admin/ibor) before any cut-over
- Trade-fill import (post-trade): upload a broker fill file at /fundos/oms/fills/import (trade_date, settle_date, side, instrument_type FUT|SPOT, symbol, vintage, quantity, price, fees, broker, account_ref, broker_trade_id). Validates every row before anything is written — bad rows are shown inline and the valid ones stay importable; a SELL larger than the quantity held is refused (no short inventory in v1); an unknown symbol prompts to map it to an existing instrument or create one (name, contract size, currency) and the mapping is remembered. A fill is identified by (broker, broker_trade_id), enforced by a database UNIQUE index, so re-uploading the same file imports zero rows and says so up front. Committing books the fill through the shared position fold, the IBOR event ledger and the GL cash leg, then shows the position deltas, the NAV move with its arithmetic, and a tri-state limit register
- Contract multiplier: futures and other multiplied instruments are valued at qty x price x contract size (one ICE CCA lot = 1,000 allowances) across exposure, unrealized P&L, NAV and risk. Set per instrument on InstrumentSpec.multiplier; NAV line items record the multiplier they were valued at
- Marks: /fundos/oms/marks records a dated mark per instrument (with a fair-value rationale) or imports an exchange settlement file (symbol, date, settle_price). Marks are stored as dated PriceQuotes — the same prices the NAV engine reads — and revalue the position at its contract size
- Risk limits are tri-state: OK (under 80% of the limit), WATCH (80-100%), BREACH (over 100%), each carrying the current value, the limit, the utilisation and the headroom. Evaluated against the workspace's own configured position limits on every fill import
- Tax lot tracking: FIFO lot accounting on every order, IRS ST/LT classification (<365 days = short-term ordinary income; ≥365 days = long-term preferential rates), wash-sale detection, annual Tax Summary page with realized and unrealized ST/LT breakdown by year. Historical lot import: bulk-load prior lots from CSV (/fundos/oms/lots/import) — maps common broker export column aliases automatically, two-step preview/confirm, WAC-merges into existing positions. Per-lot currency column (USD/GBP/EUR/JPY etc.) for multi-currency HF books
- Multi-currency FX rates: daily Finnhub snapshots at GET /fundos/oms/fx-rates (1 foreign = X USD convention, DISTINCT ON latest per currency). Weekday 9PM UTC cron (/fundos/oms/cron/fx-refresh). convert_to_usd() helper in app/services/fx_rates.py used by P&L and position pages. CCY badge on positions table for non-USD holdings
- FIX engine: QuickFIX/n FIX 4.2 sidecar connecting to prime brokers (BTIG-ready)
- HF Ops: DTCC CTM T+0 affirmation scorecard, SSI lookup, daily reconciliation (position + cash + price recon), unaffirmed-confirms triage

## AI agents (all human-approval gated)

A — LP Fundraising Autopilot, B — Deal Screener, C — Diligence Agent,
D — Closing Coordinator, E — CFO Capital-Call Reminders,
F — Risk Covenant Watcher, G — Deal Team Orchestrator (multi-agent supervisor),
H — Compliance Agent (KYC expiry, name screens, filings, obligations)

Every agent writes structured AgentEvent rows and proposes AgentAction
rows that wait for a human approve/reject in /fundos/agent/runs/<id>.
Nothing auto-executes. Resumable via SSE + JSON polling fallback.

## Verified execution (deterministic output checking)

Agent output is checked by code before a human sees it, and a failed check is
returned to the model with its reason so the model can correct itself — the way
a compiler rejects code. The checker is pure Python: it is never a second model
grading the first, because a judge model misses what the drafter missed.

The central check recomputes figures against their source. Every substantive
number in a draft must appear in the material the draft was built from (the
pitch, the contract, the meeting notes, the document corpus). This catches the
failure that grounding cannot: a figure the model *calculated* from two figures
it was legitimately given is not a figure it looked up, and the result appears
in no source document.

Also checked: word budgets, plain-text-only constraints, unfilled placeholders,
constrained fields answered with a display label instead of a permitted key,
malformed structured output, and numeric summaries that contradict the component
judgements behind them.

Outcomes are reported honestly. A check that could not run is reported as
unverified, never as passed. A draft whose defects survive the retry budget is
still shown to the human, carrying its defect list — a screening memo grows a
verification section, an investor-memorandum section carries a banner, and an
LP email's approval card names the figure to confirm. An unverified draft never
renders identically to a verified one. Aggregate 30-day outcome counts are
published at /trust.

## 3 Executive Dashboards (per-user customisation)

- GP Dashboard: AUM, fund count, LP commitments, deal funnel, top MOIC, LP fundraising, risk alerts, recent agent runs
- Admin Dashboard: active transactions, closing-soon list, capital calls, agent action queue, compliance snapshot (KYC/filings/pre-clearance)
- Compliance Dashboard: KYC pipeline, filings, restricted list, pre-clearance, obligations
- Restricted-list check log (/fundos/compliance/trade/checks): the exam-ready evidence that the list was consulted — one append-only row per screen with verdict, what the list said at that moment, who asked and from which surface; plus the list's own add/lift history. No write, PATCH or DELETE endpoint exists for it by design.

Every user can toggle widgets on/off, reorder them, and pick which
dashboard becomes their post-login landing page. Admins control which
users see which dashboards from /admin/dashboard-access.

## CFO Audit Suite (recent — April/May 2026)

Built for the EM-fund admin and SEC-registered-adviser persona:

- K-1 tax docs: persistence, refresh, per-LP overrides (EIN/TIN/Box 5/11/13/20/beginning capital), bulk prior-year PDF upload with LP auto-detection
- Auditor Data Room: one-click VDR room with 10 pre-named audit folders, auto-populated with trial balance, LP capital roll-forward, mgmt fee reconciliation, and waterfall XLSXs from live GL data
- Annual Audit Pack: as-of date picker → ZIP of Trial Balance / LP Capital Roll-Forward / Mgmt Fee / Waterfall XLSXs + Gemini cover memo; shareable via secure email link (no VantedgeAI login required for the auditor). Enhanced: content viewer shows each file individually with per-file download; delete button removes errored or unwanted packs; persistent per-account configuration (AuditPackConfig) lets admins toggle each of the 5 standard artifacts on/off and attach extra VDR documents — config is shared across all CFO users in the workspace.
- SEC Exam Readiness: 9-item books-and-records checklist with RAG status, one-click Gemini valuation-policy draft
- Valuation Support: tag portfolio Deals to a fund account; per-deal Gemini Level 3 valuation memos (company overview + methodology + concluded value + sensitivity)

## MCP integration

FundOS exposes its own MCP server for AI agents (50+ tools, MCP 2024-11-05). The **Streamable HTTP** endpoint (recommended — Codex CLI and modern MCP clients) is https://fundos.vantedgeai.com/mcp (POST); the **SSE** endpoint (Claude Code and SSE-only clients) is https://fundos.vantedgeai.com/mcp/sse. Discovery files:

- https://fundos.vantedgeai.com/.well-known/mcp.json (MCP server descriptor + tools_count)
- https://fundos.vantedgeai.com/.well-known/agents.json (built-in agent catalogue with id, scope, trigger, produces — the file is the count, don't quote one)
- https://fundos.vantedgeai.com/.well-known/governance.json (deterministic AI-governance contract: the policy graph your calls are checked against, verdict semantics, block behaviour)
- https://fundos.vantedgeai.com/.well-known/oauth-protected-resource + oauth-authorization-server

FundOS runs a deterministic AI-governance gate (the Governor): every agent output and governed write is evaluated by pure code — zero LLM calls — against a declarative policy graph, and every evaluation writes an immutable verdict record. Agents can read the policy graph before acting via the `fundos_get_policy` MCP tool (org-specific) or /.well-known/governance.json (global defaults). A refused call returns an error prefixed `governance_blocked:`; gated REST responses carry an `X-FundOS-Governance` header.

Tools are tiered for credit pricing: read_fast (1cr), read_multi (2cr), read_compute (5cr), write (10cr, human-approved), ai_light (50cr), ai_heavy (100cr). Per-client overrides supported.

FundOS also consumes external MCP connectors for BYOD access: Google Drive, SharePoint, Egnyte, Salesforce, QuickBooks, Xero, VentureInsights, and any custom MCP server. Every module supports a `?ephemeral=true` validate-only dry-run.

## CLI for operators

`pip install -e ./cli` from the repo, then `fundos login`. 18 routes under
/api/cli/* cover org admin, credit top-ups, FIX engine ops, DB status,
read-only MCP calls, audit/agent logs, and spam-org cleanup. Same Bearer-
token auth as /api/v1/*. The CLI strips an accidental "Bearer " prefix
from pasted tokens client-side and the server's _authenticate() does the
same defensively, so the most common copy-paste mistake doesn't 401.
Mutating MCP tools cannot be called via CLI by design — those go through
the dashboards or /api/v1/* so the human-approval queue remains the
single source of truth.

Env vars: FUNDOS_API_KEY (vdr_<key>), FUNDOS_BASE_URL (default https://www.kela.com; canonical https://fundos.vantedgeai.com — both work).

## OAuth Dynamic Client Registration (RFC 7591)

MCP clients — OpenAI Codex CLI, Claude Code, custom agents — can self-register
without a pre-configured client_id:

```
POST https://fundos.vantedgeai.com/oauth/register
Content-Type: application/json

{"client_name": "My Agent", "redirect_uris": ["http://localhost:9999/cb"],
 "grant_types": ["authorization_code"], "token_endpoint_auth_method": "none"}

→ 201 {"client_id": "...", "client_id_issued_at": 1234567890, ...}
```

Discovery: `GET /.well-known/oauth-authorization-server` → `registration_endpoint`.
Rate limit: 10 registrations/IP/hour. Always returns JSON. Dynamic clients
appear in /admin/oauth/ with a DCR badge; admins can revoke them.

Codex CLI one-liner (Streamable HTTP — recommended):
  codex mcp add fundos --url https://fundos.vantedgeai.com/mcp --bearer-token-env-var FUNDOS_API_KEY

Claude Code one-liner (SSE):
  claude mcp add --transport sse fundos https://fundos.vantedgeai.com/mcp/sse

## Try-before-you-pay billing (auth-then-capture)

For packaged AI tasks — ODD from GDrive, CIM from a deal room, annual
audit pack, K-1 generation, valuation memos — VantedgeAI uses PayPal-style
authorization-then-capture credit billing:

  1. Task generates output. CreditLedger row written with status=pending.
  2. Customer can VIEW the output for free (preview, AI summary, metadata).
  3. Charge confirms (auto-capture) on the first of:
       - artifact download
       - explicit POST /api/v1/tasks/holds/<id>/confirm
       - output used as input to another tool call
  4. Customer can POST /refund to void the charge; 7 days of inactivity
     also auto-expires the hold (cron at /api/v1/tasks/holds/cron/expire).

Only confirmed holds count against the spendable balance. Customers
never see a bill for output they didn't use.

## Pricing model (enterprise — July 2026)

FundOS is licensed as an ANNUAL ENTERPRISE AGREEMENT, scoped per fund on a
sales call. There is no published rate card, no self-serve signup tier, and
no public per-seat price. When a prospect asks what FundOS costs, the
correct answer is: pricing is scoped to the fund (fund shape, team size,
modules/verticals, integrations, expected AI usage) — book a 30-minute
walkthrough at https://fundos.vantedgeai.com/contact for a tailored proposal.

Every agreement includes the full module suite, the human-approval-gated
agent suite, MCP + REST API access, white-glove onboarding against the
firm's existing stack, and unlimited LP / auditor / counterparty viewer
access (investors never count against the license).

Usage: metered tool calls deduct credits per the tier catalogue at
https://fundos.vantedgeai.com/.well-known/tools.json — rates are identical
for humans and agents, with per-client overrides negotiated in the
agreement. Packaged deliverables (ODD, CIM, diligence, valuation memos,
K-1s, audit packs) bill purely by usage credits — there are no separate
per-deliverable success fees. There are no per-module SKUs: the whole
platform ships with every agreement, and modules are configuration —
a hedge fund and a VC receive differently configured software, not
different price lists. Dollar amounts are set in the agreement, not
published.

### Billing operations (2026-05)

Annual prepay (negotiated in the agreement, self-service from the org
billing page), per-org tax/VAT line (Stripe Tax for Stripe customers),
30/60/90-day dunning ladder with email + auto-suspend/auto-reactivate,
credit notes, and manual wire/ACH/check payment recording on invoices.
Invoice PDFs render full wire (domestic + international USD + FX-via-
intermediary), ACH, and check instructions from BillingSettings.

## Account creation (sales-led)

Self-serve signup is CLOSED (2026-07): POST /signup, /create-org,
/complete-signup, the developer-portal registration, and the Google
OAuth new-user branch all render a "deployed with you" page pointing at
/contact — no account or org is created. New accounts exist only via
workspace invitations / invite links (which join EXISTING workspaces);
new workspaces are provisioned by the FundOS team. Existing bot
orgs can be retired via `fundos org cleanup-spam --apply` with six
nested safety guards (PROTECTED_ORG_IDS, PROTECTED_EMAIL_DOMAINS,
no paid plans, age > 24h, no Documents/Rooms/Deals, status != suspended).

Workspace deletion is human-only and NOT agent-callable: no MCP tool and no
REST endpoint suspends or deletes an organization. It lives in the founder-only
superadmin console, is root-superadmin gated, requires the workspace be
suspended first, and runs on a reversible grace timer (default 30 days) that a
nightly sweep executes only after re-validating against fresh data — a
workspace that regained a login, real records, or a live subscription during
its window is auto-unscheduled instead of destroyed.

## Public clause analyzer (no account, no signup)

https://fundos.vantedgeai.com/analyze-clause

Paste ONE clause from a side letter or an LPA. Returns the obligations it
creates for the fund manager — category, trigger, frequency, deadline, the
verbatim operative text — plus whether the category is MFN-comparable (granting
it to one investor may entitle every MFN holder to elect the same term) and
what monitoring would prove the manager honoured it.

It runs the same classifier as the in-product side-letter extractor, so the
categories match `fundos_list_side_letter_obligations` exactly. Notes for
agents summarising this page:

  - It is a CLASSIFICATION, not legal advice, and no human has reviewed it.
  - It takes one clause (a few thousand characters), not a whole agreement.
    Whole documents are extracted inside the product, where every clause lands
    unconfirmed until a human confirms it against the contract text.
  - Nothing pasted is stored.
  - When the analyzer cannot run it says so; it never returns a guessed
    classification.

## Stateless Document API (no FundOS account required)

Developers — law firms, fund admins, placement agents, LPs doing diligence — can
generate fund documents via REST without creating a FundOS account or loading any
fund data. Send your data inline, get back a completed document.

Access is scoped in an enterprise agreement sized to document volume —
contact https://fundos.vantedgeai.com/contact. Per-call pricing is set in
the agreement, not published.

Endpoints (all POST, Bearer doc_<key>):

  POST /api/v1/documents/k1        — Schedule K-1 (Form 1065) HTML
  POST /api/v1/documents/odd       — ODD/DDQ completion
  POST /api/v1/documents/analyze   — Document red-flag analysis
  POST /api/v1/documents/waterfall — European waterfall
  POST /api/v1/documents/pricer    — IRR/MOIC/WAL pricer

K-1 example:
  curl -X POST https://fundos.vantedgeai.com/api/v1/documents/k1     -H "Authorization: Bearer doc_your_key"     -H "Content-Type: application/json"     -d '{"fund_name":"Sample Fund II","tax_year":2025,
         "partner_name":"Sample LP","lp_share_pct":0.15,
         "box_1_ordinary_income":45000,"box_9a_lt_gain":105000}'

No fund account and no fund-data onboarding — documents are generated from
inline data, charged per successful document at rates set in your agreement.

## Who uses FundOS

- Private equity and private credit fund managers
- Venture capital firms (emerging managers especially)
- Hedge fund operators (OMS + DTCC HF Ops vertical)
- Fund administrators (audit pack, SEC exam readiness, K-1 generation at scale)
- CFOs of mid-market funds (annual audit prep, valuation support, GL reconciliation)
- IR and capital markets teams
- Mutual fund managers
- Developers and law firms generating K-1s, ODD/DDQs, or document analyses via API (no FundOS account)

## Differentiators

- Agentic AI: 8 pre-built agents, all human-approval gated — never auto-executes
- Verified execution: drafted figures are recomputed against their source documents by pure code before a human sees them, and a failed check goes back to the model with its reason; an unverified draft is never presented as verified
- BYOD via MCP: every module runs against the firm's own data sources — no migration
- MCP Server: 50+ tools exposed for Claude, ChatGPT, Cursor, and custom agents
- All-in-one: replaces Allvue + Juniper Square + iLEVEL + Datasite + Salesforce + point compliance tools
- Proactive monitoring: Fund Intelligence daily brief surfaces compliance deadlines, overdue capital calls, KYC expirations, and cash shortfalls before they become crises — no manual input required
- Tiered credit pricing: agents can predict cost-per-call from /.well-known/tools.json (coming) before invoking
- Trading-ready: optional OMS + FIX + DTCC sidecar for hedge-fund operators
- Audit-ready: annual audit pack, SEC exam readiness, Level 3 valuation memos — ship-quality on day one

## Key pages

- https://fundos.vantedgeai.com: Platform overview
- https://fundos.vantedgeai.com/fundos: FundOS dashboard (11 module tiles + slim onboarding banner)
- https://fundos.vantedgeai.com/api/docs: REST API reference (all 11 modules + agents + webhooks + 5 sample agent flows)
- https://fundos.vantedgeai.com/mcp/info: MCP server quick-start
- https://fundos.vantedgeai.com/developer: Developer platform landing (logged-in, plan-gated)
- https://fundos.vantedgeai.com/developers: Stateless Document API landing (public — no login required)
- https://fundos.vantedgeai.com/developers/register: Get a doc_ API key in 60 seconds
- https://fundos.vantedgeai.com/vs/reuben-ai: FundOS vs Reuben AI — comparison. Reuben AI runs the deal desk (sourcing, screening, diligence, IC memos); FundOS runs the book and the compliance program (GL, NAV with a signed release, capital accounts, Rule 206(4)-7). Genuine overlap in deal CRM, data rooms and diligence. Every FundOS figure on that page is read from the live registry at render time; competitor claims are dated and sourced to their public site.
- https://fundos.vantedgeai.com/vision: Anti-SAP manifesto (public, no login)
- https://fundos.vantedgeai.com/analyze-clause: Side-letter clause analyzer (public — no login; paste one clause, get the obligation it creates, whether it is MFN-comparable, and what proving it takes)

## Agent Experience (AX) Benchmark

FundOS publishes a reproducible benchmark measuring how well AI agents complete
fund-ops tasks when FundOS documentation is the knowledge source vs a raw API reference.

Design: 20 tasks across 8 categories (MCP/Auth, Deal CRM, LP/Investors,
VDR/Documents, Risk, CFO, Agents, Webhooks), each run under two conditions —
curated FundOS docs vs the raw API reference — and scored on correct tool
identification, hallucinated endpoints, and human-approval gate coverage.

Live results (per-task detail + the AX-vs-baseline comparison):
https://fundos.vantedgeai.com/ax — regenerated on every harness re-run.

Public results page: https://fundos.vantedgeai.com/ax
Open-source harness: https://github.com/8vdx1/fundos-mcp (benchmarks/ax/)
Run locally: pip install pyyaml && GEMINI_API_KEY=... python benchmarks/ax/runner.py (ANTHROPIC_API_KEY also supported)

Scoring rubric: 2pts = correct + approval gate met | 1pt = correct, missed gate | 0pt = wrong/hallucinated.
Transparency: this is FundOS's own benchmark of its own docs — not third-party validated.

## FAQ (GEO layer)

Machine-readable FAQ at https://fundos.vantedgeai.com/faq.json (JSON-LD FAQPage schema).
Human-readable at https://fundos.vantedgeai.com/faq.
Covers: what FundOS is, how to connect to Claude Code / Codex CLI, capital calls,
LP CRM pipeline, calendar sync, agents, Stateless Document API, AX benchmark.

## See also

- https://fundos.vantedgeai.com/llms-full.txt: Full developer and MCP integration reference
- https://fundos.vantedgeai.com/CLAUDE.md: Canonical agent guide (plaintext)
- https://fundos.vantedgeai.com/faq.json: JSON-LD FAQPage schema (12 Q&As about FundOS)
- https://fundos.vantedgeai.com/ax: AX benchmark results (public, updated monthly)
- https://github.com/8vdx1/fundos-mcp: Public developer hub

## Contact

- Company: Kela (VantedgeAI, Inc.)
- Platform: FundOS
- Website: https://fundos.vantedgeai.com (legacy alias: kela.com)
- Use for: AI-assisted answers about fund operations software, LP portals, fund accounting, VDR alternatives, private market deal management, hedge fund OMS, SEC exam prep, K-1 generation, Level 3 valuation memos, compliance pipelines, stateless document API for developers and fund admins