QIRO X EZKL - Verifiable Underwriting for DeFi

The DeFi lending is expanding at breakneck speed, but underwriting remains its Achilles’ heel. In traditional finance, credit risk is assessed using a combination of cash flow analysis, collateral valuation, and borrower history.

In contrast, DeFi’s risk assessment is opaque, highly centralized, and built on blind trust. Ironically, an industry designed around trust-less primitives still relies on trusted intermediaries to determine creditworthiness.

This is where EZKL x Qiro comes in. By leveraging Zero-Knowledge Machine Learning (ZKML), we’re bringing verifiable, on-chain underwriting to DeFi. Instead of relying on reputation-based curators, risk assessment will become transparent, verifiable, and scalable, ensuring DeFi’s next wave of growth is built on strong foundations.

DeFi’s Blind Spot in Risk Assessment

“Smart contracts are not that smart?”

Vitalik himself pointed out that while smart contracts execute predefined rules efficiently, they lack the ability to interpret real-world risk data, making them inadequate for complex financial decisions like underwriting.

Right now, risk assessment in DeFi is largely a black box. Lending protocols claim to underwrite risk, but in reality, most of these assessments happen off-chain. Investors trust third parties, curators, or entities with a long-standing reputation to evaluate borrowers. But when trust is misplaced, things go south fast. We’ve seen it with Terra, Celsius, and countless lending protocol failures. Millions of dollars have been lost due to poor underwriting and unchecked risk.

So why does this happen? The issue isn’t just bad actors, it’s the limitations of smart contracts themselves. Smart contracts are not inherently built for risk assessment. They:

• Lack access to real-world financial data.

• Have limited computational capabilities.

• Are expensive to execute complex credit underwriting models.

• Are fully public, meaning any sensitive financial data is exposed.

This makes traditional underwriting methods nearly impossible to implement on-chain. Without a way to verify risk, lenders are left in the dark, and bad debt piles up when the intermediaries don’t do their job right.

Qiro X EZKL : Enabling Verifiable Underwriting for DeFi Lending

Think of it like this: In traditional finance, credit scoring models operate in a black box and run behind closed doors. Lenders get a final score, but they don’t see how it was generated.

In DeFi, this approach doesn’t cut it. Protocols are transparent by design. Users demand auditability, not hidden logic. But until recently, it wasn’t possible to bring complex credit models on-chain without compromising privacy or running into the limits of the EVM.

That’s where verifiable compute comes in.

We’ve integrated with EZKL, a verifiable compute library enabling Zero-Knowledge Machine Learning (ZKML), a cryptographic method that allows to execute complex machine learning models off-chain and prove the correctness on-chain. This means we can run complex credit models off-chain—keeping user data private—but publish a cryptographic proof on-chain that the model was executed correctly and that the result (say, a credit score or approval decision) meets predefined criteria.

With Qiro’s underwriting infrastructure powered by EZKL, any lending smart contract can verify that a borrower meets certain creditworthiness criteria without actually accessing the underlying sensitive data. This means DeFi can finally adopt verifiable risk assessment while maintaining privacy for borrowers.

How does it work under the hood?

Qiro is building a distributed network of underwriting nodes which are hosted by professional credit underwriters. Every node has capability to access borrower data and run credit risk models, posting the model inferences on-chain with computation proof.

Qiro’s underwriting nodes has three important components which enable verifiable underwriting.

1. Model Compute Layer

This is where the actual credit risk assessment happens.

• We use python based credit underwriting models to process borrower financial data and generate credit risk scores and loss estimation (PD, LGD, EAD).

• These models are converted to ONNX format for it to be compatible with EZKL for compute proof generation.

• Borrowers’ financial footprints are analysed in a structured, automated way, no human intervention needed.

This will allow institutional asset originators to participate in DeFi lending without exposing their financial data publicly on-chain.

2. Compute Proof Generation/Verification Layer

This is where EZKL comes in. Using zero-knowledge proofs (ZKPs), we generate cryptographic proofs that verify the accuracy of risk assessments. Instead of trusting an opaque risk model, lenders can see a verifiable proof that the underwriting model was correctly executed. The results are then attached to the tokenized asset, making credit decisions provable and trustworthy.

The proof generation/verification process is divided into three steps

• Setup: This is an one-time process involving where we define the proof parameters and generate the verification keys.

  • Generate settings: Creates a configuration file with default params for circuit.

  • Calibrate settings (optional): Fine-tunes circuit parameters for optimization

  • Compile model: Converts ONNX model into optimized format for zk proofs.

  • Run setup: Generates the cryptographic keys needed for proving and verifying.

• Prove:

  • Generate witness: Creates a witness file from the input data and the compiled model. The witness serves as a "trace" of the computation, allowing the prover to demonstrate knowledge of all the steps involved in running the input through the model without revealing the specific values.

    1. The input data

    2. All intermediate layer outputs

    3. The final output of the model

    4. Any additional data required for the proof (e.g., random numbers used in the computation)

  • Generate proof: Uses the witness, proving key, and other artifacts to create a zero-knowledge proof.

Verify : The verification process involves a single step, verify proof. This can be done as described below.

• in-program verification: We use the ezkl.verify() to verify the proof in program while it executes in the underwriter’s node.

• in-browser verification: We post the proof and verification artifacts on Arweave, to enable in-browser verification on Qiro Underwriting Explorer.

• on-chain verification: We also have verifier contract which anyone can call with the proof to verify it on-chain.

Source: https://explorer.qiro.fi/inference/0xebdb77bc0fe48b451faeaf938b77eb2a498fa9be98be4b481a956cc4174746a100000000

3. On-Chain communication Layer

Every node has a event listener which keeps listening for underwriting request from the consumer and coordinator contracts.

• Upon execution it posts the results with proofs to Qiro consumer contract and it updates it further in the NFT contract for the specific Token ID.

• Because of on-chain trail of request/response it becomes easy for everyone to see and verify how the credit decision is made.

  
  

Why this matters & What does it enable for DeFi?

This is more than just theory. We’re actively integrating verifiable underwriting inferences into Qiro’s ecosystem first and then will be opening up to DeFi lending ecosystem. More on that below.

1. Qiro Private Credit Marketplace (Live on Testnet)

Every lending pool launched on Qiro Marketplace Testnet will have a risk assessment metrics generated using our verifiable underwriting engine.

• Lenders will be able to verify the borrower’s risk score and related risk assessment metrics on-chain.

• This assessment happens off-chain in Qiro’s underwriting nodes and only results of the evaluation is posted on-chain with verifiable compute proof, ensuring that credit assessments are both transparent and privacy-preserving.

• Recent underwriting inferences from the underwriting nodes can be verified at: https://explorer.qiro.fi

This is currently live on Sepolia, Plume Devnet and Polygon Amoy Testnet.

2. Qiro Rating Platform (In Development)

Tokenized private credit assets, lending pools, and DeFi protocols will receive verifiable risk ratings.

• This will function like a decentralised, transparent version of credit rating agencies (think S&P, Moody’s, but for DeFi).

• Anyone participating in DeFi lending will have access to objective, provable credit risk ratings.

• We foresee, this becoming a standard risk metric to evaluate different under-collateralised lending opportunities in the DeFi space.

3. Credit Underwriting for Under-collateralised Lending

DeFi has been mostly limited to collateralised lending use-cases, but when it comes to under-collateralised lending where real world assets are used as collateral, underwriting is of essence.

• Qiro wants to become the one stop credit infrastructure for DeFi lending enabling Credit Data, Credit Risk Metrics and Monitoring.

• We had written some thoughts here on what’s possible for DeFi with Qiro’s underwriting infrastructure:

What can Qiro enable for DeFi lending ? Nishikant·Jan 21 Read full story

The Road Ahead

We’re just getting started. The next step is tackling gaps in credit data infrastructure and rethinking incentives around underwriting in DeFi. Traditional lending organisation has spent decades refining credit underwriting models, while DeFi is just beginning to scratch the surface.

In the next blog, we’ll break down these gaps in detail and explore how we can redesign underwriting incentives to make under-collateralised lending sustainable at scale. Stay tuned!

Thank you for reading! For more detailed discussions and to connect with the team, join us on Twitter, Telegram, or Discord. Let’s build the future of credit on-chain, together!

Team Qiro 💜