Skip to content

Verifiable Reasoning Graphs — A Filecoin-Native Substrate for AI Agent Decisions #2073

Open
Open
Verifiable Reasoning Graphs — A Filecoin-Native Substrate for AI Agent Decisions#2073
Labels
Open Grant
@Michsantozz

Description

@Michsantozz
Michsantozz
opened on Apr 7, 2026

Reviewer: this proposal can be verified in 10 seconds before reading further.

Paste this into your terminal:

curl -s https://selantar.vercel.app/api/mediate | jq '.price, .erc8004, .filecoin'

If the response is not a live ERC-8004 + x402 + Filecoin PDP service running in production, this proposal is fraudulent and should be rejected immediately.

If it is, please read past this line.

The reference implementation is at https://github.com/Michsantozz/selantarpd — public, MIT, every TX hash in the README clickable on BaseScan.

Reference Implementation — Already in Production

This proposal is not greenfield. The reasoning-graph substrate it generalizes is already running in Selentar (https://github.com/Michsantozz/selantarpd) — a Care Protocol for B2B contracts, live on Base Sepolia and Filecoin Calibration. The grant work extracts and opens the substrate as a standalone SDK + spec.

Production evidence (every link verifiable on-chain):

What Verification
Selentar live https://selantar.vercel.app
Public source https://github.com/Michsantozz/selantarpd
ERC-8004 Agent #2122 (Identity + Reputation + Validation, all 3 registries deployed) Identity TX · agent.json
ERC-8004 Validation Registry — deployed by us because the official one was not yet live on Base Sepolia Deploy TX
Filecoin storage with PDP via Synapse SDK — every verdict dual-written ipfs://|filecoin://, continuous Proof of Data Possession on-chain PieceCID: bafkzcibd3qaqjzlcknf7am35f6cbioxsspnx7qy2unltvjwlc3cypngepxojqjr6 · Deposit TX · Public verification: /api/verify-evidence
MetaMask Advanced Permissions (ERC-7715 + ERC-7710) — production early adopter, real USDC moving autonomously via DelegationManager + Pimlico bundler USDC redemption TX
x402 pay-per-use mediation — discoverable, USDC-paywalled, no API key GET https://selantar.vercel.app/api/mediate
Hash-chain reasoning trail (SHA-256 + canonical JSON, the substrate this grant generalizes) — every mediation event chained, replayable, dual-stored IPFS+Filecoin Agent decision log

Why this matters for the grant: The substrate this proposal opens — content-addressed reasoning DAGs, FVM-anchored verification, Filecoin-backed retention via PDP — already runs end-to-end inside Selentar's mediation pipeline (Empath → Strategist → Clara advisory chains, hash-chained event sourcing, dual IPFS+Filecoin storage with PDP, replay engine, ERC-8004 verdict registration). This grant funds extracting that substrate into @selentar/reasoning-graph (SDK) + ReasoningGraphRegistry.sol (FVM contract) + a public spec, MIT/Apache-2 dual-licensed, so any agent in the ecosystem can use it — not just Selentar.

This is leverage, not promise: the reference implementation is already in production with verifiable on-chain receipts.

Open Grant Proposal: Verifiable Reasoning Graphs

Project Name: Verifiable Reasoning Graphs — A Filecoin-Native Substrate for AI Agent Decisions

Proposal Category: Integrations (primary), with strong overlap into FVM, Storage, and Developer and data tooling.

Individual or Entity Name: Individual — Michael Nunes (Brazil). All grant payments and the grant agreement will be in the name of the individual proposer.

Proposer: Michsantozz

Project Repo(s): Reference implementation (Selantar production source, MIT, public): https://github.com/Michsantozz/selantarpd. The grant deliverables — the @selantar/reasoning-graph SDK, ReasoningGraphRegistry.sol, and the public RFCs — will live in a dedicated new public repo under the same GitHub account, MIT-licensed, created at the start of M1 if the grant is awarded.

(Optional) Filecoin ecosystem affiliations: None. No prior or current work relationships with Protocol Labs, Filecoin Foundation, FFDW, or any organization in the Protocol Labs Network.

(Optional) Technical Sponsor: None at the time of submission. Actively seeking input from the FVM and Filecoin Plus teams via the devgrants issue thread and grants@fil.org.

Do you agree to open source all work you do on behalf of this RFP under the MIT/Apache-2 dual-license?: Yes.

Project Summary

AI agents don't make decisions — they walk reasoning graphs. A perception step feeds an analysis step, which spawns counterfactuals, which collapse into a judgment, which triggers an action. Today this graph is ephemeral: it lives in RAM during a model call, gets summarized into a one-line log, and dies. Six months later, when somebody asks "why did the agent decide that?", all anyone has is the answer — never the path. This is the load-bearing problem of the agent economy: as agents move money, mediate disputes, and act on behalf of humans, no one will trust them if their reasoning evaporates the instant it ends.

This project builds Verifiable Reasoning Graphs — an open-source SDK, an FVM smart contract, and an open spec that turn every AI agent decision into a content-addressed Merkle DAG, aggregated into Filecoin sectors via Lighthouse, provably retained by PDP, verified on-chain by an FVM contract that reads Filecoin deal state directly via built-in actor precompiles, with each node selectively decryptable via Lit Protocol and reproducible via Lassie. The result: every reasoning step of every autonomous agent becomes a cryptographically verifiable, retrievable, re-executable artifact whose existence is enforced by the Filecoin network itself.

Selantar — a production Care Protocol already running ERC-8004 mediations on Base Sepolia, with Synapse SDK + PDP integration live on Filecoin Calibration — will be the first production consumer. The grant deliverables (SDK, FVM contract, encrypted disclosure spec, verification gateway) are independent open-source artifacts that any ERC-8004 agent can adopt; Selantar is the proof that the substrate works under real load and real economic stakes ($0.10 USDC per mediation via x402, with x402 having recently moved to the Linux Foundation and processed 100M+ payments in 2026).

Impact

The 2026 Filecoin Network Strategy explicitly states the year's focus: "driving paid, onchain storage deals and improving network economics... improve storage provider economics through expanded offerings, like compute colocation, new revenue channels, and performance-based rewards." This proposal is a direct implementation of that strategy in a brand-new vertical — the AI agent economy — that Filecoin has not yet captured. Every Selantar mediation is a paid x402 transaction that triggers a Filecoin write; every reasoning graph stores 50–200 nodes, multi-modal (CBOR, PDF, JSON, evidence binaries); the precedent corpus grows monotonically as new verdicts cite prior verdicts via CID. This is sustained, recurring, economically motivated demand for Filecoin storage from a vertical that today has none.

The pain point being addressed: AI agents are about to act autonomously at scale, but their reasoning has nowhere trustworthy to live. Logs are deletable, IPFS pins disappear silently, S3 is opaque, and Ethereum mainnet is too expensive for raw evidence. Filecoin is the only network in the world where a smart contract can verify, on-chain and in the same transaction, that a specific dataset is currently retained — because FVM built-in actor precompiles let a Solidity contract read live MarketActor state. Take that primitive away and the design collapses. The risk of not getting this right is that the agent economy adopts opaque, centralized evidence layers as a default — and Filecoin loses a vertical that should structurally belong to it.

What success looks like: by month 12 post-grant, Verifiable Reasoning Graphs is the default reasoning substrate for any ERC-8004 agent that needs to defend a decision later; Selantar runs all production mediations against Filecoin Mainnet; at least one external agent has independently adopted the SDK; and the FVM contract pattern (deal-state verification in the same tx as anchor registration) becomes a reference implementation that other Filecoin builders cite when explaining why FVM precompiles matter.

Outcomes

The final outcomes of this grant are:

  1. @selantar/reasoning-graph — an MIT-licensed npm package implementing the Reasoning Graph data model: CBOR-encoded ReasoningNode with canonical hashing, DAG construction and traversal APIs, two-tier write pipeline (IPFS hot path under 100ms + Lighthouse aggregator warm path with active deal in ≤6h), full integration with Synapse SDK against Filecoin Calibration and Mainnet, complete test suite, public docs.

  2. ReasoningGraphRegistry.sol — an FVM smart contract deployed on Filecoin Calibration and Mainnet that uses filecoin-project/fvm-solidity MarketAPI and MinerAPI precompiles to verify deal state directly on-chain at registration time and on every isAnchorLive query. ERC-8004 agent signature verification via EIP-712. Full Solidity source, deployment scripts, integration tests against live MarketActor.

  3. Two open specs published as Markdown RFCs in the SDK repo:

    • "Cross-Chain Reasoning Anchors via Content Addressing" — a CID-determinism bridge spec showing how a Base ERC-8004 receipt and an FVM anchor reference the same content without any oracle or bridge contract.
    • "Encrypted Reasoning Graphs v1" — node envelope format, ACL grammar (referencing ERC-8004 reputation, party addresses, dispute IDs), Merkle proof format for selective disclosure, reproducibility receipt structure.

  4. Public verification gateway — GET /api/anchor/:rootCid returning live deal state from FVM, plus a public read-only dashboard listing every ERC-8004 agent currently storing reasoning graphs on Filecoin via the SDK with live PDP health per agent.

  5. Selantar in production on Filecoin Mainnet, plus at least one second consumer (either an external design partner or a documented internal-fallback agent) running the SDK on Mainnet.

  6. Public technical writeup on the architecture, FVM precompile usage, aggregation economics, x402 + retrieval fusion, and lessons learned, plus a live presentation at a Filecoin community call.

Success metrics:

  • ≥10 reasoning graph anchors registered on FVM Calibration in M2; ≥100 on FVM Mainnet by end of M4
  • ≥3 production reasoning graphs with mixed-encryption nodes verifiable end-to-end in M3
  • ≥2 distinct production agents on Filecoin Mainnet by end of M4
  • ≥3 successful Lassie-based reproductions committed to the FVM registry in M3
  • Verification gateway p95 latency under 500ms over 7 consecutive days in M3
  • 100% test coverage in CI against live Calibration network from M1 onward
  • All code MIT-licensed, all specs published, both repos public from M1

Data Onboarding

Projected Filecoin storage onboarding from Selantar production alone, as the first consumer of the SDK. Other agents adopting the SDK multiply this number; these projections do not include them.

  • Month 1: ~5 GB (development + initial reasoning graphs from 3 production mediation cases on Calibration during M1)
  • Month 3: ~20 GB (M2 + M3 deliverables: dozens of test reasoning graphs, encrypted nodes, reproducibility evidence on Calibration)
  • Month 6: ~80 GB (M4 Mainnet migration complete; Selantar production runs onboarding all reasoning graphs to Filecoin Mainnet; 1,000–3,000 mediations total at ~30 MB per multi-modal mediation including evidence)
  • Month 12: ~400 GB (sustained production volume from Selantar plus at least one external SDK consumer; precedent corpus growing monotonically as new verdicts cite prior ones via CID)

These projections are conservative — they assume a single SDK consumer scaling linearly. Each multi-modal reasoning graph includes 50–200 CBOR-encoded reasoning nodes plus binary evidence (contract files, GitHub history snapshots, communication logs, transaction receipts, encrypted payloads), aggregated into Filecoin sectors via Lighthouse so per-CID cost remains economical despite the small individual file size.

Adoption, Reach, and Growth Strategies

Target audience: developers building autonomous AI agents on the ERC-8004 standard (Identity, Reputation, Validation registries) and any AI agent that needs to defend a decision later — legal tech, healthcare, B2B contracts, mediation, compliance, audit. The ERC-8004 ecosystem is small but growing fast in 2026 alongside x402 (now under the Linux Foundation, with Coinbase, Cloudflare, Stripe, Google, AWS, Microsoft, Visa, Mastercard, Amex, Shopify, and Circle backing) and the broader agent-economy push from MCP, Coinbase AgentKit, and Virtuals Protocol.

How the audience is currently engaged: the Selantar Care Protocol already operates as ERC-8004 Agent #2122 on Base Sepolia with reputation 90/100 and is one of the first production agents in the registry. The proposer has direct visibility into the ecosystem through this position.

First 10 users: the SDK is built so any ERC-8004 agent can integrate in under 30 minutes via a single npm install plus a Quickstart tutorial. Outreach happens through the ERC-8004 working group, the Filecoin #fil-builders and #fvm channels, the FVM Office Hours community calls, and direct introductions to other ERC-8004 agents discoverable via the Identity Registry on Base. The M4 deliverable explicitly requires one external agent in production on Mainnet — this is enforced as an acceptance criterion, not aspirational.

First 100 users: post-grant, the SDK becomes a critical production dependency of Selantar, which is a paid product running x402 mediation at $0.10 USDC per call. This means maintenance is enforced by the business model. Public dashboard, technical writeup, community call presentation, and the Encrypted Reasoning Graphs spec all serve as adoption funnels. Specific funnel: any developer searching for "ERC-8004 agent evidence storage" or "FVM smart contract deal verification" should land on the SDK.

Development Roadmap

The grant is broken into 4 milestones over 12 weeks. All work is performed by a single engineer (Michael Nunes, the proposer). All deliverables ship under MIT license with public repos from day one.

Milestone 1 — Reasoning Graph SDK + Lighthouse Aggregation Pipeline

Duration: 3 weeks (weeks 1–3) — Funding: $12,000 — People: 1 (Michael Nunes, full-stack engineering)

Generalizes Selantar's existing working Filecoin integration (already live on Calibration with verified depositWithPermit TX at height 3588118, dated 2026-03-31) into a standalone framework-agnostic SDK.

Functionality after completion:

  • @selantar/reasoning-graph published to npm under MIT
  • CBOR-encoded ReasoningNode schema with canonical hashing (recursively sorted keys → reproducible CIDs)
  • DAG construction API: graph.addNode(parents, payload) returns CID and links parents
  • DAG traversal API: graph.walk(rootCid) returns full reasoning tree
  • Two-tier write pipeline: IPFS hot path under 100ms + Lighthouse aggregator warm path producing active Filecoin deals within 6 hours (Lighthouse explicitly positioned its February 2026 release around AI storage infrastructure — direct alignment with this vertical)
  • Built-in circuit breaker (CLOSED / OPEN / HALF_OPEN) — already battle-tested in Selantar production, generalized into the SDK
  • Full test suite covering: deterministic CID generation, sector aggregation correctness, deal activation polling, recovery from aggregator failure, against live Filecoin Calibration in CI
  • Public Quickstart docs and one-page integration tutorial

Acceptance: 3 real Selantar mediations stored as full reasoning graphs on Calibration, all nodes provably aggregated into Filecoin sectors with active PDP, complete graph walk verifiable end-to-end in under 30 seconds.

Milestone 2 — FVM-Native Receipt Registry + CID-Bridge to Base ERC-8004

Duration: 4 weeks (weeks 4–7) — Funding: $14,000 — People: 1 (Michael Nunes)

Builds the technical heart of the proposal: an FVM smart contract that reads Filecoin deal state directly via built-in actor precompiles, with no oracle and no bridge contract.

Functionality after completion:

  • ReasoningGraphRegistry.sol deployed on FVM Calibration
  • Uses filecoin-project/fvm-solidity MarketAPI.getDealActivation, MarketAPI.getDealDataCommitment, and MarketAPI.getDealProvider to verify deal state at anchor registration time and on every isAnchorLive query
  • ERC-8004 agent signature verification via EIP-712 (compatible with agents on Base)
  • Helper SDK: registerAnchor(rootCid, dealId, commP, agentSigner) calls the FVM contract from any chain
  • Public RFC: "Cross-Chain Reasoning Anchors via Content Addressing" — defines how a Base ERC-8004 receipt embeds the same CID + CommP that the FVM registry holds; verifiers on either chain independently confirm consistency without an oracle. The CID itself is the bridge — content addressing makes trust unnecessary
  • Reference indexer that watches both Base ERC-8004 events and FVM AnchorRegistered events, surfaces inconsistencies (none should ever exist if the spec is followed)
  • Public read endpoint: GET /api/anchor/:rootCid returning live deal state

Acceptance: ≥10 reasoning graph anchors registered on FVM Calibration with verified live deal state; at least 5 of them cross-anchored from Base Sepolia ERC-8004 receipts; spec published with public discussion link; indexer running and matching 100% of events across chains.

Milestone 3 — Encrypted Selective Disclosure + Reproducibility (Lassie primary, Bacalhau stretch)

Duration: 3 weeks (weeks 8–10) — Funding: $14,000 — People: 1 (Michael Nunes)

Adds privacy-preserving and reproducibility-preserving layers to the reasoning graph.

Functionality after completion:

  • Per-node Lit Protocol encryption with programmable access conditions referencing ERC-8004 reputation, party addresses, and dispute IDs
  • Selective Merkle proofs over the DAG: prove "node X exists in graph G with payload hash H" without revealing siblings
  • Reproducibility primary path: Lassie + integrity proofs. A graph.reproduce(rootCid, agentLogic) API retrieves the full reasoning DAG via Lassie (the canonical Filecoin/IPFS retrieval client), re-executes the agent logic locally against the retrieved bytes, and commits (originalHash, reproducedHash, lassieRetrievalReceipt) back to the FVM registry under a Reproduction mapping. Cryptographic proof of input integrity is end-to-end via CID match
  • Reproducibility stretch goal: Bacalhau compute-over-data. If Bacalhau's Filecoin-sector job execution surface is production-stable by mid-grant, the same API gains a mode: "bacalhau" option that executes at the storage provider with no retrieval. Documented as a stretch because the 2026 Filecoin compute-colocation roadmap is still maturing — Lassie path ships regardless
  • Public RFC: "Encrypted Reasoning Graphs v1" — node envelope, ACL grammar, Merkle proof format, reproducibility receipt structure
  • Worked example: Selantar's three production cases (Clínica Suasuna, E-commerce Quebrado, Freelancer Fantasma) re-executed end-to-end with output hashes matching original verdicts

Acceptance: Three production reasoning graphs with mixed-encryption nodes live on Calibration; selective disclosure proofs verifiable by an independent party with only the public verifier; ≥3 successful Lassie-based reproductions committed to the FVM registry. Bacalhau path delivered if upstream stability allows; clearly documented either way.

Milestone 4 — Mainnet + Paid Retrieval via x402 + Second Consumer

Duration: 2 weeks (weeks 11–12) — Funding: $8,000 — People: 1 (Michael Nunes)

Moves everything to Filecoin Mainnet and onboards the second SDK consumer.

Functionality after completion:

  • Migration of the aggregation pipeline and the registry contract to Filecoin Mainnet + FVM Mainnet
  • Selantar's full production mediation flow migrated to the Reasoning Graph substrate on Mainnet
  • Retrieval integrated into Selantar's GET /api/verify-reasoning endpoint with FilCDN where available, Lassie as the universal fallback. FilCDN is acknowledged in the 2026 Filecoin Network Strategy as still maturing; the SDK auto-selects FilCDN when the CID is served by it, falls back to Lassie/IPFS gateways otherwise
  • x402 payment header settles both the verification fee and the retrieval cost in a single USDC transaction — first known fusion of x402 micropayments with Filecoin retrieval, regardless of which retrieval backend serves the bytes
  • ≥1 external ERC-8004 agent (the design partner) integrated and producing reasoning graphs in production on Mainnet, OR — as a documented fallback — a second ERC-8004 identity operated as a distinct agent (Selantar's contract-parsing sub-agent) producing its own reasoning graphs as a second SDK consumer
  • Public technical writeup published on the Filecoin blog or HackMD detailing architecture, FVM precompile usage, aggregation economics, and x402+retrieval fusion
  • Live demo at a Filecoin community call (FilOz, FVM Office Hours, or equivalent)

Acceptance: ≥2 distinct production agents on Filecoin Mainnet using the SDK; ≥100 reasoning graphs anchored on FVM Mainnet during the milestone; x402 + paid retrieval working end-to-end; public writeup published; community call presentation delivered.

Total Budget Requested

Milestone # Description Deliverables Completion Date Funding
M1 Reasoning Graph SDK + Lighthouse Aggregation Pipeline @selantar/reasoning-graph npm package, two-tier write pipeline, full test suite on Calibration, Quickstart docs, 3 real reasoning graphs stored Week 3 from contract signature $12,000
M2 FVM-Native Receipt Registry + CID Bridge ReasoningGraphRegistry.sol deployed on FVM Calibration, EIP-712 agent verification, Cross-Chain Reasoning Anchors RFC, indexer, public read endpoint Week 7 $14,000
M3 Encrypted Selective Disclosure + Reproducibility Per-node Lit encryption, selective Merkle proofs, Lassie reproducibility (Bacalhau stretch), Encrypted Reasoning Graphs v1 RFC, 3 worked production examples Week 10 $14,000
M4 Mainnet + Paid Retrieval + Second Consumer Mainnet migration, FilCDN+Lassie retrieval, x402+retrieval fusion, ≥2 production consumers, public writeup, community call Week 12 $8,000
TOTAL $48,000

Maintenance and Upgrade Plans

The Reasoning Graph SDK becomes a critical production dependency of Selantar, which is a paid product running x402 mediation at $0.10 USDC per call (with x402 having moved to the Linux Foundation in 2026 and processed 100M+ payments in its first six months under that governance). This means Selantar literally cannot ship without keeping the SDK working — maintenance is enforced by the business model, not by promises.

Post-grant roadmap (self-funded from Selantar mediation revenue):

  • v0.2: Multi-provider redundancy per piece (resilience against single SP failure — each PieceCID stored across ≥3 providers)
  • v0.3: IPNI announcement so reasoning graphs are discoverable via standard Filecoin network indexing
  • v0.4: Solidity helper library so any EVM contract on any chain can verify a reasoning graph anchor by calling FVM via cross-chain message
  • v0.5: Native FVM actor (Wasm) for reasoning graphs that don't need Solidity, halving gas costs

The repo accepts external PRs, has public issues, and the spec documents (Cross-Chain Reasoning Anchors, Encrypted Reasoning Graphs v1) live in the same repo so the community can iterate. All code MIT, all specs CC-BY.

Team

Team Members

  • Michael Nunes — Solo founder, sole engineer. Brazilian. Design + product + full-stack engineering background. Building Selantar single-handed.

Team Member LinkedIn Profiles

Team Website

Relevant Experience

The proposer has already built and deployed the technical foundation that this grant extends. Selantar is in production today as ERC-8004 Agent #2122 on Base Sepolia with reputation score 90/100, with the following live components verifiable on-chain:

The Selantar codebase already includes a working Synapse SDK + PDP integration on Filecoin Calibration, a live x402 paywall on /api/mediate using the Linux Foundation x402 standard, MetaMask Delegations (ERC-7710 / ERC-7715) for settlement execution on Base, production-grade circuit breakers, canonical JSON hashing, simulate-before-write safety, and three end-to-end mediation flows in production. This grant is not a greenfield project — it is the generalization of working production infrastructure into a Filecoin-native primitive that any agent can use.

Solo execution is a feature for a 12-week scoped grant: zero coordination overhead, single source of decisions, fast iteration. The technical scope is achievable because the foundation already exists and has been validated under real load.

Team code repositories

Additional Information

How I learned about the Open Grants Program: through the filecoin-project/devgrants repo while researching Filecoin grant opportunities for the Selantar Care Protocol.

Best email for grant agreement and next steps: atendimento@ultraself.com.br

Additional context:

This proposal is strictly Filecoin-focused and technically aggressive on purpose. The program guidance states:

"The Devgrants program will prioritize funding that enhances functionality for Filecoin Network while de-emphasizing funding for projects that are exclusively IPFS, libp2p, and other stacks we may have previously supported."

This proposal uses IPFS only as the hot-path latency layer in a two-tier pipeline. Every load-bearing primitive — sector aggregation, PDP, FVM precompiles for live deal-state verification, Lassie reproducibility, FilCDN-where-available paid retrieval, x402 + retrieval-market fusion — is Filecoin-native and unbuildable elsewhere. The proposal is a direct implementation of the 2026 Filecoin Network Strategy (paid onchain deals + new SP revenue channels + compute colocation) in the AI agent vertical.

Risks and mitigations (kept short — full text available on request):

  • Solo founder bus factor → all code MIT, all specs public from day 1, anyone can fork
  • filecoin-project/fvm-solidity precompile interface changes → pin specific version, integration tests against live Calibration MarketActor, fallback to Zondax fork
  • Lighthouse aggregator availability → aggregator interface abstracted, can swap to Web3.Storage / direct Curio / self-hosted Boost
  • Bacalhau scheduling unreliable for small workloads → M3 stretch only, Lassie path ships regardless
  • FVM Mainnet stability for M4 → bounded by upstream readiness, Calibration is fully tested first
  • Design partner doesn't materialize → documented internal fallback (second ERC-8004 identity for Selantar's contract-parsing sub-agent)

If a reviewer wants more aggression on any specific surface (deeper Bacalhau integration, IPNI announcement in M1, native Wasm actor instead of Solidity), the budget can absorb it via reallocation across milestones — happy to negotiate scope before contract signature.

NO WORK WILL BEGIN UNTIL THE GRANT AGREEMENT IS SIGNED BY BOTH PARTIES.

Metadata

Metadata

Assignees

No one assigned

    Labels

    Open Grant

    Type

    No type

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions