Build companies as composable protocols.

DecentCompany is a decentralized company framework: a set of smart contracts, APIs, and governance patterns to run projects as programmable entities – with onchain work graphs, royalty rights, and modular voting.

Get the Blueprint For protocol builders

For protocol teams, DAO / network operators, and tooling builders.

Framework, not platform

Own the company logic.

Contracts first: WorkGraph, RoyaltyVault, Governance.
APIs first: REST/GraphQL + webhooks.
Governance adapters: Quadratic, Conviction, Ranked.

Today’s “companies” don’t fit decentralized work.

Most tools for “decentralized” work still assume a traditional company:

Centralized admin rights. A few multisig signers decide everything.
One-off bounties. Contributors get paid once and lose upside.
Opaque governance. Proposals are social rituals, not programmable objects.
Disconnected tooling. Tasks, payments, and governance live in separate silos.

Protocols, DAOs, and network-native companies need identity & reputation, programmable governance, verifiable work graphs, and APIs that can be embedded anywhere. That’s what DecentCompany provides.

A framework for decentralized companies.

DecentCompany is not a SaaS dashboard. It’s a framework – opinionated contracts, APIs, and patterns for:

Spaces – projects or organizations.
WorkGraphs – DAGs of WorkUnits (tasks, milestones).
RoyaltyVaults – revenue vaults that stream value back to contributors.
Governance – proposals, votes, and execution with pluggable adapters.

Use it as your protocol’s governance and work engine, embed it under your own UI, or fork and extend it for your network.

Six layers, one coherent framework.

DecentCompany is built as a set of composable layers. You can adopt them all, or start with the ones you need.

1. Identity & Reputation

Verifiable credentials for contributors and agents, with reputation scores derived from verified outputs and dispute history. Pluggable identity sources (DIDs, wallets, offchain credentials).

2. Governance Layer

Spaces with roles and policies, powered by a proposal engine and modular voting adapters (Quadratic, Conviction, Ranked). Policies are code, not PDF.

3. WorkGraph Layer

A DAG of WorkUnits, each with a spec, optional bounty, and acceptance criteria. Your work backlog becomes a verifiable onchain graph.

4. Verification Layer

Proof-of-Output: artifact hashes, evidence URIs, and verifier approvals or optimistic challenge. Optional oracles can attach KPI-based bonuses.

5. Economic Layer

RoyaltyVaults hold revenue. When WorkUnits are verified, WorkShares are minted to contributors, representing future royalty rights.

6. Execution Layer

API-first: all actions exposed via REST/GraphQL plus event webhooks, with dry-run support for proposals and executions before committing onchain.

Architecture overview.

How the frontend, API layer, smart contracts, and off-chain services compose into a Decentralized Company OS.

Architecture Overview
 +---------------------------------------------------------------+
 |                        Decentralized Company OS              |
 +---------------------------------------------------------------+
 |                                                               |
 |  [ Frontend UI / SDK ]                                        |
 |   - Spaces dashboard                                          |
 |   - Governance board                                          |
 |   - WorkGraph task board                                      |
 |   - RoyaltyVault earnings view                                |
 |                                                               |
 |  [ REST / GraphQL API Layer ]                                 |
 |   - /spaces, /roles, /proposals, /signals, /votes            |
 |   - /workunits (create, claim, submit, verify)               |
 |   - /royaltyvault (deposit, claim)                           |
 |   - Webhooks: decision.finalized, execution.attempted        |
 |                                                               |
 +---------------------------------------------------------------+
 |                     Smart Contract Layer (EVM L2)            |
 |                                                               |
 |   Governance.sol                                              |
 |     - Proposal registry                                       |
 |     - Voting adapters (Quadratic, Conviction, Ranked)        |
 |                                                               |
 |   WorkGraph.sol                                               |
 |     - WorkUnit lifecycle                                      |
 |     - Proof-of-Output verification                            |
 |     - Mint WorkShares                                         |
 |                                                               |
 |   RoyaltyVault.sol                                            |
 |     - Revenue deposits                                        |
 |     - Royalty streaming / claims                              |
 |                                                               |
 +---------------------------------------------------------------+
 |                     Off-Chain Services                        |
 |                                                               |
 |   - IPFS / Arweave: store artifacts & evidence               |
 |   - KPI Oracles: fetch performance metrics                   |
 |   - Identity & Reputation: VC issuance, passport updates     |
 |   - Notification service: task updates, payout events        |
 |                                                               |
 +---------------------------------------------------------------+
 |                     External Integrations                     |
 |                                                               |
 |   - Payment rails: stablecoins, SEPA Instant (via bridge)    |
 |   - AI Agents: connect via MCP / API for task automation     |
 |   - Verification network: bonded verifiers, challenge games  |
 |                                                               |
 +---------------------------------------------------------------+

Flow summary

Governance – Create Space → define roles → submit proposals → vote → execute.
WorkGraph – Create WorkUnits → claim → submit proof → verify → finalize → mint WorkShares.
RoyaltyVault – Revenue deposited when projects earn → royalties streamed to WorkShare holders.
Off-chain – Artifacts on IPFS/Arweave, KPI oracles feed bonus logic, verifiers bonded for trust.
Agents – AI agents claim microtasks via API; humans handle creative and complex work.

Governance as an API, not a ceremony.

Spaces, roles, policies, proposals, signals, and votes – wired into a programmable flow.

Core objects

Space – a project or organization.
Role – defines capabilities (verbs on assets).
Policy – code-based rules (OPA/Rego or JS).
Proposal – intent to change state (budget, milestones, roles).
Signal – preference expressions and constraints.
Vote – decision units, routed to chosen adapters.

Lifecycle

Create a Space
Define roles, assets, and policies: who can propose, who can verify, how funds move.
Submit a Proposal
Example: “Launch campaign with €50k budget”, linked to WorkUnits, funding, and role assignments.
Signal Preferences
Stakeholders express priorities (e.g. brand vs speed vs risk) and constraints per asset.
Vote via adapter
Quadratic, Conviction, or Ranked Choice adapters compute outcomes via a shared interface.
Execute
Update the WorkGraph, fund escrows, and mint WorkShares when tasks finalize.

Onchain primitives, not black boxes.

WorkGraph.sol

Manages the lifecycle of WorkUnits: creation, claiming, submission, verification, and finalization.

Events for WorkUnitCreated, Claimed, Submitted, Verified, Finalized.
Functions: createWorkUnit, claim, submit, verify, finalize.

Interface (short)

interface IWorkGraph {
  event WorkUnitCreated(uint256 id, bytes32 specHash, uint256 bounty);
  event Claimed(uint256 id, address worker);
  event Submitted(uint256 id, bytes32 outputHash, string[] evidenceURIs);
  event Verified(uint256 id, address verifier, bool approved);
  event Finalized(uint256 id, address worker, uint256 sharesMinted);

  function createWorkUnit(
    bytes32 specHash,
    uint256 bounty,
    address[] calldata verifiers,
    uint8 kRequired
  ) external returns (uint256 id);

  function claim(uint256 id) external;
  function submit(uint256 id, bytes32 outputHash, string[] calldata evidenceURIs) external;
  function verify(uint256 id, bool approved) external;
  function finalize(uint256 id) external;
}

View full interface

pragma solidity ^0.8.20;

interface IWorkGraph {
    event WorkUnitCreated(uint256 id, bytes32 specHash, uint256 bounty);
    event Claimed(uint256 id, address worker);
    event Submitted(uint256 id, bytes32 outputHash, string[] evidenceURIs);
    event Verified(uint256 id, address verifier, bool approved);
    event Finalized(uint256 id, address worker, uint256 sharesMinted);

    function createWorkUnit(
        bytes32 specHash,
        uint256 bounty,
        address[] calldata verifiers,
        uint8 kRequired
    ) external returns (uint256 id);

    function claim(uint256 id) external;
    function submit(uint256 id, bytes32 outputHash, string[] calldata evidenceURIs) external;
    function verify(uint256 id, bool approved) external;
    function finalize(uint256 id) external; // pays bounty if funded + mints WorkShares
}

RoyaltyVault.sol

Holds revenue and pays out based on WorkShares minted on verified completion.

depositRevenue, mintWorkShares, claimRoyalties.
Events for RevenueDeposited and RoyaltyClaimed.

Interface (short)

interface IRoyaltyVault {
  event RevenueDeposited(uint256 amount);
  event RoyaltyClaimed(address indexed holder, uint256 amount);

  function depositRevenue(uint256 amount) external;
  function mintWorkShares(address to, uint256 units) external;
  function claimRoyalties() external returns (uint256);
}

View full interface

pragma solidity ^0.8.20;

interface IRoyaltyVault {
    event RevenueDeposited(uint256 amount);
    event RoyaltyClaimed(address indexed holder, uint256 amount);

    function depositRevenue(uint256 amount) external;
    function mintWorkShares(address to, uint256 units) external;
    function claimRoyalties() external returns (uint256);
}

Governance.sol

Routes proposals and votes through registered voting adapters and triggers execution.

createProposal, vote, execute.
Events for ProposalCreated, Voted, Executed.

Interface (short)

interface IGovernance {
  event ProposalCreated(uint256 id, string title, bytes32 specHash);
  event Voted(uint256 proposalId, address voter, uint256 weight);
  event Executed(uint256 proposalId);

  function createProposal(string calldata title, bytes32 specHash)
    external
    returns (uint256 id);

  function vote(uint256 proposalId, uint256 weight) external;
  function execute(uint256 proposalId) external;
}

View full interface

pragma solidity ^0.8.20;

interface IGovernance {
    event ProposalCreated(uint256 id, string title, bytes32 specHash);
    event Voted(uint256 proposalId, address voter, uint256 weight);
    event Executed(uint256 proposalId);

    function createProposal(string calldata title, bytes32 specHash) external returns (uint256 id);
    function vote(uint256 proposalId, uint256 weight) external;
    function execute(uint256 proposalId) external;
}

REST & GraphQL first, with modular governance.

Everything you see onchain is accessible via a clean API surface.

Core endpoints

POST /spaces – create projects or organizations.
POST /spaces/{id}/roles – define roles & capabilities.
POST /spaces/{id}/proposals – submit proposals.
POST /spaces/{id}/signals – submit preference vectors.
POST /spaces/{id}/votes – cast votes.
POST /workunits – create tasks.
POST /workunits/{id}/claim – claim tasks.
POST /workunits/{id}/submit – submit proofs.
POST /workunits/{id}/verify – approve/reject outputs.
POST /royaltyvault/deposit – deposit revenue.
POST /royaltyvault/claim – claim royalties.

OpenAPI Specification (Draft)

openapi: 3.0.3
info:
  title: Decentralized Company API
  version: 0.1.0
  description: >
    API for managing decentralized projects, governance, tasks (WorkGraph),
    and royalty distribution. Supports human and AI contributors.

servers:
  - url: https://api.decentcompany.io/v1

tags:
  - name: Spaces
    description: Project or organization containers
  - name: Governance
    description: Proposals, voting, and preference signaling
  - name: WorkGraph
    description: Task creation, claiming, submission, and verification
  - name: RoyaltyVault
    description: Revenue deposits and royalty claims

paths:
  /spaces:
    post:
      tags: [Spaces]
      summary: Create a new space (project)
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                name: { type: string }
                description: { type: string }
                owner: { type: string, format: address }
      responses:
        '201':
          description: Space created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Space'

    get:
      tags: [Spaces]
      summary: List all spaces
      responses:
        '200':
          description: Array of spaces
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Space'

  /spaces/{spaceId}/roles:
    post:
      tags: [Spaces]
      summary: Define a role with capabilities
      parameters:
        - name: spaceId
          in: path
          required: true
          schema: { type: string }
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                name: { type: string }
                capabilities:
                  type: array
                  items:
                    type: object
                    properties:
                      asset: { type: string }
                      verbs:
                        type: array
                        items: { type: string }
      responses:
        '201':
          description: Role created

  /spaces/{spaceId}/proposals:
    post:
      tags: [Governance]
      summary: Create a proposal
      parameters:
        - name: spaceId
          in: path
          required: true
          schema: { type: string }
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                title: { type: string }
                specHash: { type: string }
                votingAdapter: { type: string }
      responses:
        '201':
          description: Proposal created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Proposal'

    get:
      tags: [Governance]
      summary: List proposals for a space
      parameters:
        - name: spaceId
          in: path
          required: true
          schema: { type: string }
      responses:
        '200':
          description: Array of proposals
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Proposal'

  /spaces/{spaceId}/signals:
    post:
      tags: [Governance]
      summary: Submit preference signal for an asset or proposal
      parameters:
        - name: spaceId
          in: path
          required: true
          schema: { type: string }
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                assetId: { type: string }
                weights:
                  type: object
                  additionalProperties: { type: number }
                credits: { type: integer }
                curve: { type: string }
      responses:
        '201':
          description: Signal recorded

  /spaces/{spaceId}/votes:
    post:
      tags: [Governance]
      summary: Cast a vote on a proposal
      parameters:
        - name: spaceId
          in: path
          required: true
          schema: { type: string }
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                proposalId: { type: string }
                weight: { type: integer }
      responses:
        '201':
          description: Vote recorded

  /workunits:
    post:
      tags: [WorkGraph]
      summary: Create a WorkUnit (task)
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                specHash: { type: string }
                bounty: { type: integer }
                verifiers:
                  type: array
                  items: { type: string, format: address }
                kRequired: { type: integer }
      responses:
        '201':
          description: WorkUnit created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WorkUnit'

  /workunits/{id}/claim:
    post:
      tags: [WorkGraph]
      summary: Claim a WorkUnit
      parameters:
        - name: id
          in: path
          required: true
          schema: { type: string }
      responses:
        '200':
          description: WorkUnit claimed

  /workunits/{id}/submit:
    post:
      tags: [WorkGraph]
      summary: Submit proof of completion
      parameters:
        - name: id
          in: path
          required: true
          schema: { type: string }
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                outputHash: { type: string }
                evidenceURIs:
                  type: array
                  items: { type: string }
      responses:
        '200':
          description: Submission recorded

  /workunits/{id}/verify:
    post:
      tags: [WorkGraph]
      summary: Verify a WorkUnit
      parameters:
        - name: id
          in: path
          required: true
          schema: { type: string }
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                approved: { type: boolean }
      responses:
        '200':
          description: Verification recorded

  /royaltyvault/deposit:
    post:
      tags: [RoyaltyVault]
      summary: Deposit revenue into RoyaltyVault
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                amount: { type: integer }
      responses:
        '200':
          description: Revenue deposited

  /royaltyvault/claim:
    post:
      tags: [RoyaltyVault]
      summary: Claim royalties for caller
      responses:
        '200':
          description: Royalty claimed
          content:
            application/json:
              schema:
                type: object
                properties:
                  amount: { type: integer }

components:
  schemas:
    Space:
      type: object
      properties:
        id: { type: string }
        name: { type: string }
        description: { type: string }
        owner: { type: string }
    Proposal:
      type: object
      properties:
        id: { type: string }
        title: { type: string }
        specHash: { type: string }
        status: { type: string }
    WorkUnit:
      type: object
      properties:
        id: { type: string }
        specHash: { type: string }
        bounty: { type: integer }
        status: { type: string }

Governance adapters

Voting adapters implement a shared interface and can be swapped per Space or proposal type.

Quadratic Voting – express intensity with anti-whale damping.
Conviction Voting – continuous support over time, ideal for funding streams.
Ranked Choice – prioritize roadmaps and competing proposals.

Register custom adapters in the governance contract and route different proposal classes to different decision mechanisms.

Early blueprint: contracts, APIs, SDK, demo.

The first public release focuses on core protocol and developer surface area.

Solidity contracts

WorkGraph.sol
RoyaltyVault.sol
Governance.sol

Auditable, forkable, and designed as primitives.

OpenAPI spec & TypeScript SDK

Full REST/GraphQL blueprint plus a typed SDK for managing Spaces, WorkGraphs, and RoyaltyVault flows from your own applications.

Demo UI with dry-run mode

Minimal UI for Spaces, proposals, WorkGraph visualization, and RoyaltyVault dashboard – including dry-run mode for proposals and executions.

Read the Blueprint (docs) Explore the Contracts (GitHub) Try the Demo

Links are placeholders – wire them to your docs, repo, and demo deployment.

Built for protocol & tooling teams.

DecentCompany is for protocol teams, DAO / network operators, and tooling builders who need programmable primitives instead of closed platforms.

Protocol teams – add a native work & governance layer to your chain or app.
DAO tooling builders – integrate WorkGraphs, royalties, and modular governance.
Networks – give contributors ongoing royalty rights, not just one-off bounties.

You get a clear onchain data model (Spaces, WorkUnits, WorkShares), a clean API surface, and a governance playground with pluggable adapters.

GitHub Documentation Request integration support