Open Sourcing the Execution Layer of Structured Credit

The structured credit industry has long relied on Intex — a proprietary system whose CDI files power deal modeling, bond pricing, and cashflow distribution across the market. These files are non-human-readable, require licensed tools to execute, and lock every participant into a single vendor's ecosystem.

Today we're open sourcing graam-flows — a deterministic cashflow engine that replaces proprietary CDI files with human-readable, executable deal representations. No vendor lock-in. No translation layer. Just code that runs.

The repo is live at github.com/GraamOrg/graam-flows.

1. The Problem: Fragmentation and Translation

Structured credit today operates across disconnected systems. Legal definitions live in prospectuses. Models live in spreadsheets or proprietary platforms. Each participant independently rebuilds the same deal — manually translating from legal prose to models to analytics.

This creates a workflow that is manual, duplicated, and error-prone. There is no guarantee that the model you're running matches the actual deal terms. And when every firm rebuilds the same structure independently, discrepancies are inevitable.

2. The Solution: Executable Deal Representation

Rather than proprietary CDI files, graam-flows uses a human-readable domain-specific language (DSL) to define deal structure, payment priority, and trigger behavior. A deal definition is code — it can be read, shared, versioned, and executed without licensed tooling.

This means a single deal file can be shared across counterparties, executed deterministically by any party, and converted to or from natural language — enabling a new class of AI-native workflows.

3. What graam-flows Provides

The engine covers the core execution stack for structured credit:

Collateral projections — CPR, CDR, and severity modeling with term structure support
Waterfall execution — sequential, pro-rata, and shifting interest mechanics
Bond analytics — price, yield, spread, duration, and WAL calculations
Scenario analysis — base, stress, and custom scenario definitions

graam-flows is deterministic — given the same inputs, it produces the same outputs every time. This is critical for reproducibility across counterparties and audit trails.

4. Why Open Source

The execution layer of structured credit shouldn't be a black box. When deal economics are opaque, participants can't independently verify cashflow mechanics, modeling discrepancies go undetected, and the entire market depends on a single vendor's implementation.

Open sourcing the engine means:

Counterparties can share and verify deal definitions without vendor dependencies
Models can be audited, tested, and extended by anyone
AI agents can read, write, and reason about deal structures directly
Innovation happens at the application layer, not behind a license

5. From Documents to Executable Models

The real shift is eliminating the translation layer entirely. Instead of manually converting a 300-page prospectus into a spreadsheet model, an agent can parse the document, extract the waterfall logic, and produce an executable deal definition — one that can be validated, run, and shared immediately.

This is how Graam's platform works: upload a prospectus, and the agent produces a full deal model backed by graam-flows. Structure the deal, price tranches, forecast defaults, generate docs — all from a single workflow.

6. Get Started

The repo is available now:

dotnet build

dotnet test

dotnet run --project src/GraamFlows.Api