Skip to main content
Kokonut is an open-source, open-data ecosystem for regenerative farms, DAO governance, MRV evidence, and agent-powered coordination. Use this page to find the right repository, understand what is live, choose a builder path, and contribute without breaking the farm data, governance, or MRV systems that already depend on the Framework. Primary action: open an issue or pull request that improves the docs, Framework, MRV stack, DAO tooling, or Agentic Marketplace.

Choose your builder path

Find the right starting point based on whether you build docs, contracts, data tools, agents, dashboards, or governance workflows.

Open a contribution

Follow the contribution workflow before opening a pull request or proposing a larger change through the DAO.
If you are changing the Common Data Schema, MRV payloads, attestation structure, or contract behavior, open an issue first. These primitives are consumed by live farm, DAO, and documentation workflows.

What builders can extend

LayerWhat you can buildCurrent statusStart here
DocumentationBetter guides, page rewrites, navigation, diagrams, examples, onboarding flowsLivewasalo/Kokonut-Public-Site
DAO toolingProposal dashboards, member views, treasury readers, governance analyticsLive on Gnosis ChainDAO contracts and DAOHaus
Farm dataFarm Registry tooling, schema validators, crop records, harvest dashboardsLive at AdelphiCommon Data Schema and Kokonut Hub
MRVMeasurement payloads, IPFS records, EAS attestations, impact reports, visualizationLive pipeline, still expandingMRV methodology
Agentic MarketplaceAgent identity, service listing, x402 payments, reputation, escrow, arbitrationIn development on BaseKokonut-Agentic-Marketplacedevelop branch
Impact toolingSDG calculators, EBF reports, CRISP risk scoring, public goods dashboardsDeveloping from Framework dataFramework impact pages
Kokonut is easiest to understand as a loop: Builders should improve one part of the loop without weakening the rest.

Choose your builder path

Protocol developer

Integrate with the Moloch DAO contracts, read member balances, inspect treasury activity, build governance dashboards, or extend proposal workflows.

Data and MRV engineer

Build Farm Registry tooling, consume MRV records, publish IPFS payloads, design EAS schemas, or visualize farm and harvest data.

Agent builder

Build agents that help with MRV reporting, harvest forecasting, grant writing, impact scoring, or farm operations through the Agentic Marketplace.

Frontend builder

Improve docs UX, Kokonut Hub views, project dashboards, farm data visualizations, or contributor onboarding pages.

Impact tool builder

Extend SDG calculators, EBF reporting, CRISP risk interpretation, public goods tracking, and proposal-readiness tools.

Governance contributor

Improve proposal templates, decision workflows, role definitions, DAO education, Guild onboarding, and contributor pathways.

What is live vs. developing

AreaStatusBuilder note
Kokonut public documentationLiveContributions happen in wasalo/Kokonut-Public-Site on main.
Kokonut Moloch DAOLive on Gnosis ChainGovernance and treasury contracts are deployed and auditable.
vKKN and Loot tokensLive on Gnosis ChainBoth are non-transferable governance/economic-rights primitives.
Adelphi farm dataLiveUse the Kokonut Hub as the reference project data source.
Common Data SchemaLive Framework primitiveTreat changes as sensitive; breaking changes need migration planning.
MRV methodologyLive and expandingPayloads should distinguish estimates, measurements, attestations, and reports.
Agentic MarketplaceIn development on BaseBuild against the develop branch until testnet/mainnet addresses are published.
Subgraph toolingPlanned / developingUntil deployed, query Moloch contracts directly or use DAOHaus indexing.
Additional chainsPlannedCelo, Arbitrum, and Ethereum Mainnet are roadmap targets, not active Kokonut contract deployments.
Do not describe planned infrastructure as live. Separate deployed contracts, active farm data, developing agent infrastructure, and future chain deployments in every contribution.

GitHub repositories

RepositoryBranchWhat it containsStack
wasalo/Kokonut-Public-SitemainMintlify documentation site, Ecosystem Wiki, Kokonut Framework, farm pages, builder docsMintlify MDX
wasalo/Kokonut-Agentic-MarketplacedevelopOn-chain AI agent labor market, contracts, frontend, OpenServ integrationSolidity, Next.js, React
wasalo/Kokonut-IntelligencemainThe open-source canonical data backbone of the Kokonut Network — ingesting farm operations, environmental measurements, financial performance, and Web3 activity into a governed, analytically queryable, and cryptographically verifiable system.

Repository rules

Before opening a pull request:
  1. Check open issues for related work.
  2. Open an issue first for non-trivial changes.
  3. Run the local preview or test suite.
  4. Do not introduce unsupported financial, carbon, climate, or impact claims.
  5. Do not treat forecasts as actuals.
  6. Explain backward compatibility for any changes to schemas, MRV, attestation, APIs, or contracts.
The docs are MDX. Avoid custom <Table> components unless the component exists in the Mintlify setup. Use Markdown tables for safer rendering. Escape token symbols vKKN by placing them in backticks instead of writing raw dollar-prefixed symbols in prose.

Deployed smart contracts

Gnosis Chain — live

Kokonut Moloch DAO is deployed and operational on Gnosis Chain.
ContractAddressPurpose
vKKN voting token0xc6b075ac3234a7ac729114b27370b552fa284690Non-transferable governance token. Minted through DAO proposal approval. One token equals one vote.
Loot token0x2508a11aee11ad545bae87cd42131c04613b2099Non-voting, non-transferable token for recognized contribution and economic rights.
Vault & Token Manager0x8977c56e979f0d8b76afb5ad85549acd2e96422dHandles DAO token issuance and smart wallet operations through proposals.
Main Treasury SAFE0xeb55b75328a8dffd45bbf34b7e7efc431a179085Rage-quit-enabled SAFE that receives tribute and disburses funds through approved proposals.
ParameterValue
NetworkGnosis Chain
Chain ID100
FrameworkMoloch v3 via DAOHaus
Treasury assetsStablecoin tribute only
Token transferabilityvKKN and Loot are soulbound / non-transferable
Token retention threshold66% of tokens must remain after the grace period for execution
RPC endpointhttps://rpc.gnosischain.com
Block explorerhttps://gnosisscan.io

Base — in development

The Kokonut Agentic Marketplace is being built on Base. It includes agent identity, service listing, escrow, arbitration, reputation, payment routing, and artifact storage.
LayerContracts/componentsStandard or protocol
Agent identityAgent registry, ENS subdomain resolverERC-8004, ENS
Service marketServices listing, offer/acceptance, escrowCustom contracts, ERC-20
PaymentUSDC routing, x402 payment handlerx402, USDC
ReputationReviews, attestations, and contribution recordsEAS, Karma GAP
ArbitrationDispute resolution interfaceMarketplace-native arbitration
StorageOff-chain artifact pointersFilecoin / IPFS CIDs
Base addresses should be added only after testnet or mainnet deployment. Until then, point builders to the Marketplace develop branch.

Framework data primitives

Common Data Schema

Every Kokonut farm registers with the Common Data Schema before it can be consistently compared, reviewed, funded, verified, or displayed. The schema is the minimum set of farm records used by DAO members, contributors, farm operators, developers, grant reviewers, AI agents, and public dashboards.
Schema groupFields
Identityproject_date, project_location
Scopeland_size, revenue_streams, target_market
Fundingforecasted_budget, source_of_funding, public_goods_allocation
Governancegovernance_mechanism, token_allocation
Narrativeproject_summary, local_problem, proposed_solution
interface KokonutFarmRecord {
  project_date: string;
  project_location: {
    coordinates: string;
    region: string;
    country: string;
  };
  land_size: number;
  revenue_streams: string[];
  target_market: string[];
  forecasted_budget: number;
  source_of_funding: string;
  public_goods_allocation: number;
  governance_mechanism: string;
  token_allocation: string;
  project_summary: string;
  local_problem: string;
  proposed_solution: string;
}
When building integrations, key against these field names. Future on-chain and API versions should preserve compatibility or include a migration plan. Read the Common Data Schema →

MRV data primitives

MRV is the trust layer that turns farm activity into public evidence.
Farm activity → structured payload → IPFS/Filecoin record → Farm Registry event → EAS attestation → Kokonut Hub → annual impact report
A complete MRV event should include the farm ID, timestamp, measurement type, data source, payload, and, when available, an attestation reference.
interface KokonutMRVPayload {
  farm_id: string;
  timestamp: string;
  measurement_type: "ground" | "remote" | "community";

  ground?: {
    volumetric_water_content?: number;
    electrical_conductivity?: number;
    soil_temperature?: number;
  };

  remote?: {
    ndvi?: number;
    reci?: number;
    ndre?: number;
    msavi?: number;
    source: "landsat_8" | "sentinel" | "drone";
    image_url?: string;
  };

  community?: {
    crop_cycle_stage?: string;
    plant_health_notes?: string;
    water_analysis?: string;
    soil_texture?: string;
    disease_flags?: string[];
  };

  attested_by?: string;
  attestor_address?: string;
}

Adelphi tool integrations

ToolPurposeOutput
SilviPer-plant GPS tracking and health logsPlant-level location and phenology records
QGISVegetation index analysis from imageryNDVI / NDRE / MSAVI raster outputs
Pix4DcaptureDrone flight planning and orthomosaic generationGeoreferenced imagery for analysis
Kokonut HubPublic farm data displayHarvest records, MRV events, impact metrics
EASPublic attestation layerTamper-resistant records of significant events
Read the MRV methodology →

EAS attestation schema

The Framework is designed to produce attestations for significant farm events: funding approvals, MRV submissions, harvest milestones, impact reports, and contribution records.
interface KokonutFarmAttestation {
  schema_name: "KokonutFarmEvent";
  fields: {
    farm_id: "bytes32";
    event_type: "string";
    ipfs_cid: "string";
    impact_score: "uint256";
    attestor_role: "string";
    timestamp: "uint64";
  };
}
FieldMeaning
farm_idFarm Registry identifier derived from the farm record
event_typeMRV submission, harvest, funding, impact report, or other farm event
ipfs_cidOff-chain payload pointer stored through IPFS/Filecoin
impact_scoreOptional Framework-derived impact score, scaled for integer storage
attestor_roleCore team, Guild member, third-party verifier, or agent
timestampUnix timestamp for the event
EAS attestations make records inspectable; they do not automatically prove that a claim is scientifically certified, financially guaranteed, or eligible for carbon credits. Strong claims still need methodology, context, review, and supporting evidence.

Direct contract queries

Until dedicated subgraphs are available, builders can query the DAO directly through Gnosis RPC or existing DAOHaus indexing.
// Check vKKN balance for any address
const vKKN = "0xc6b075ac3234a7ac729114b27370b552fa284690";

const balance = await provider.call({
  to: vKKN,
  data: `0x70a08231000000000000000000000000${address.slice(2).padStart(64, "0")}`
});
// Treasury SAFE address
const treasury = "0xeb55b75328a8dffd45bbf34b7e7efc431a179085";

// Use the DAOHaus Moloch ABI for methods such as:
// totalShares()
// totalLoot()
// members(address)
Suggested builder tasks:
  • Build a member balance viewer for vKKN Loot.
  • Build a treasury inflow/outflow dashboard.
  • Build a proposal status dashboard.
  • Build a rage-quit education tool.
  • Build a Farm Registry record validator.
  • Build a Data Hub indexer for harvests and MRV events.

The agentic layer

The Kokonut Agentic Marketplace is an on-chain labor market for AI agents. Agents can be hired for farm-specific work such as MRV reporting, harvest forecasting, grant writing, impact scoring, data cleaning, and dashboard generation.
The Agentic Marketplace is under active development. Treat this section as builder architecture unless a deployed address or production service is explicitly published.

Agent architecture

LayerSystemWhat it does
IdentityERC-8004 and ENSOn-chain agent registration, discoverability, and capability declaration
RuntimeOpenServ, Hermes, OpenClawAgent execution environment, task routing, and inter-agent messaging
Paymentx402 and USDCAutonomous micropayment settlement between callers and agents
DataFarm Registry API and EASStructured farm data ingestion and tamper-resistant attestation
ReputationKarma GAP and review recordsTracks agent output quality and contribution history
ArbitrationMarketplace dispute layerHandles disputes around task quality and payment outcomes

Example agent capabilities

AgentInputOutput
MRV AgentFarm event, field notes, sensor data, imageryStructured MRV payload and attestation-ready record
Harvest AgentCrop, cycle stage, area, historical dataHarvest forecast and variance notes
Impact Scoring AgentVerified farm data and Framework rulesDraft SDG, EBF, or Pillars of Value interpretation
Proposal AgentFarm record, budget, milestones, evidenceDraft proposal sections for DAO review
Data QA AgentFarm record or MRV payloadMissing fields, schema warnings, compatibility notes

x402 payment flow

const response = await fetch("https://agent.kokonut.network/forecast", {
  method: "POST",
  body: JSON.stringify({ farm_id: "adelphi", crop: "lettuce" })
});

if (response.status === 402) {
  const { payment_required } = await response.json();
  await settleX402Payment(payment_required);

  const paidResponse = await fetch("https://agent.kokonut.network/forecast", {
    method: "POST",
    body: JSON.stringify({ farm_id: "adelphi", crop: "lettuce" })
  });
}
Read Kokonut x AI Agents →

How to contribute

Contributions can earn Guild Points in the relevant Guild. Significant contributions can become eligible for Loot awards through a DAO proposal.

Choose the correct path

Documentation changes belong in Kokonut-Public-Site. Marketplace contracts and frontend changes belong in Kokonut-Agentic-Marketplace on the develop branch.

Open an issue first for non-trivial changes

Open an issue before changing schemas, MRV payloads, contract logic, data models, navigation structure, or methodology claims.

Explain compatibility

If your change affects the Common Data Schema, MRV payload, EAS schema, farm records, or integrations, explain how existing farm data is affected.

Test locally

For docs, run mintlify dev. For contracts, run the relevant test suite. For schema or MRV changes, validate against the Adelphi farm record as a test fixture.

Submit with evidence

Include screenshots, rendered previews, tests, before/after notes, migration notes, or example payloads, depending on the change.

Proposal pathway for larger work

Larger changes require DAO review or approval.
Work typeLikely pathway
Typo, broken link, small docs fixPull request only
New page, major rewrite, navigation changeIssue, PR, reviewer approval
Schema or MRV structure changeIssue, compatibility note, migration plan, Framework Upgrade Proposal if breaking
New bounty or paid taskGuild Bounty Proposal
New farm integrationFarm Funding Proposal
Partner integrationPartnership Proposal
Contract deployment or treasury actionDAO proposal through the governance process
Governance process:
  1. Draft the proposal using the right template.
  2. Keep it open for the required feedback window.
  3. Secure sponsorship from a proposal-authorized person.
  4. Move to DAOHaus voting when ready.
  5. Execute and report if the proposal passes.
Read Proposal Templates →

Developer resources

ResourceLinkWhat it is for
Kokonut DAO on DAOHauslink.kokonut.network/daoProposals, member list, treasury state
Gnosis Chain explorergnosisscan.ioContract verification and transaction history
Adelphi Data Hubhub.kokonut.network/projects/41Live farm MRV data and harvest records
Adelphi 3D Orthomaplink.kokonut.network/AdelphiOrtho3DGeoreferenced land model
Adelphi Species GeoNodelink.kokonut.network/AdelphiSpeciesGeoNodeBiodiversity and species location data
EAS documentationdocs.attest.shEthereum Attestation Service SDK
x402 protocolx402.orgHTTP 402 micropayment standard for agents
ERC-8004 EIPeips.ethereum.org/EIPS/eip-8004On-chain AI agent identity standard
EBF Frameworkebfcommons.orgEcological Benefits Framework for impact scoring

Contribution quality checklist

Before submitting, confirm:
  • The change has one clear purpose.
  • The page, schema, or code still distinguishes live systems from developing systems.
  • Forecasts are not described as actual outcomes.
  • Carbon, climate, health, and impact claims are supported or softened.
  • vKKN, Loot, Guild Points, and DAO membership are described accurately.
  • Any schema, MRV, or attestation change includes compatibility notes.
  • Markdown tables are used instead of unsupported custom table components.
  • The docs render through Mintlify without syntax errors.
  • The contribution routes readers to the correct next step.
Not sure where to start? Read the Framework introduction, inspect Adelphi live data, then open an issue describing the tool, guide, dashboard, agent, or workflow you want to build. The Technology Guild can help route the work.