C-Corp Founder Journey

An end-to-end walkthrough of forming a Delaware C-Corp, issuing founder equity, running governance, and operating day-to-day — using the v2 corp CLI and REST API.

Every example shows both local mode (no server required) and remote mode (against a running corp-server). The commands and API paths are identical; only the transport differs.

Install

Install the corp binary via Cargo (cargo install corp-cli) or download a pre-built binary from the releases page. For remote mode, run corp-server serve or point CORP_API_URL at a hosted instance.

---

1. Form the entity

CLI — local mode

No server, no setup. State is written to bare git repos under CORP_DATA_DIR (default: ./corp-data).

corp --local form create \
  --name "Acme AI Inc" \
  --entity-type c_corp \
  --jurisdiction DE

The command prints the new entity_id and records it as @last automatically.

CLI — remote mode

corp form create \
  --name "Acme AI Inc" \
  --entity-type c_corp \
  --jurisdiction DE

Set the active entity so subsequent commands don’t need an explicit ID:

corp use @last

API

curl -X POST http://localhost:8000/v1/entities \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "legal_name": "Acme AI Inc",
    "entity_type": "c_corp",
    "jurisdiction": "DE"
  }'

Response includes entity_id — save it as ENTITY_ID for the rest of the examples.

---

2. Advance through formation

Formation follows a state machine: pending → documents_generated → documents_signed → filing_submitted → filed → ein_applied → active.

CLI — check status

# local
corp --local form status @last

# remote (active entity already set)
corp form status @last

CLI — generate documents

corp --local form advance @last

This moves the entity from pending to documents_generated and creates the articles of incorporation and related formation documents.

CLI — list and sign documents

corp --local form documents @last
# prints each document_id

corp --local form sign @last \
  --signer-name "Jane Smith" \
  --signer-role "Incorporator" \
  --signer-email "[email protected]" \
  --signature-text "Jane Smith" \
  --consent-text "I certify the above is accurate."

@last after form documents refers to the entity; after form sign it refers to the most recently listed document. You can also pass a full document_id directly.

CLI — advance to filing

corp --local form advance @last   # → documents_signed, then → filing_submitted

API — advance formation

curl -X POST http://localhost:8000/v1/formations/$ENTITY_ID/advance \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

API — sign a document

curl -X POST http://localhost:8000/v1/documents/$DOCUMENT_ID/sign \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "signer_name": "Jane Smith",
    "signer_role": "Incorporator",
    "signer_email": "[email protected]",
    "signature_text": "Jane Smith",
    "consent_text": "I certify the above is accurate."
  }'

CLI — confirm state filing and EIN

Once the state accepts the filing and the IRS assigns an EIN:

corp --local form confirm-filing @last \
  --confirmation-number "7654321"

corp --local form advance @last   # → filed

corp --local form confirm-ein @last \
  --ein "12-3456789"

corp --local form advance @last   # → active

MCP prompt

Form a Delaware C-Corp called Acme AI Inc, advance through document generation, and sign all required documents.

---

3. Add contacts

Contacts are the people and organizations associated with an entity. They are referenced by cap table holders, governance seats, and obligations.

CLI

corp contacts add \
  --name "Jane Smith" \
  --email "[email protected]" \
  --contact-type individual \
  --category founder

corp contacts add \
  --name "Bob Chen" \
  --email "[email protected]" \
  --contact-type individual \
  --category founder

API

curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/contacts \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Jane Smith",
    "email": "[email protected]",
    "contact_type": "individual",
    "category": "founder"
  }'

Save the returned contact_id values — you’ll need them for cap table holders.

---

4. Issue founder equity

CLI — initialize cap table

corp cap-table init

CLI — create an instrument

corp cap-table create-instrument \
  --cap-table-id @last \
  --symbol CS \
  --instrument-kind common_equity \
  --par-value "0.00001" \
  --authorized-units 10000000

CLI — create holders

corp cap-table create-holder \
  --name "Jane Smith" \
  --holder-type individual \
  --contact-id $JANE_CONTACT_ID

corp cap-table create-holder \
  --name "Bob Chen" \
  --holder-type individual \
  --contact-id $BOB_CONTACT_ID

CLI — issue shares

# Jane: 6,000,000 shares
corp cap-table issue \
  --cap-table-id $CAP_TABLE_ID \
  --instrument-id $INSTRUMENT_ID \
  --recipient-contact-id $JANE_CONTACT_ID \
  --recipient-name "Jane Smith" \
  --grant-type common_stock \
  --shares 6000000

# Bob: 4,000,000 shares
corp cap-table issue \
  --cap-table-id $CAP_TABLE_ID \
  --instrument-id $INSTRUMENT_ID \
  --recipient-contact-id $BOB_CONTACT_ID \
  --recipient-name "Bob Chen" \
  --grant-type common_stock \
  --shares 4000000

CLI — verify the cap table

corp cap-table show
# or with @last: corp cap-table show @last

API — initialize cap table

curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/cap-table \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

API — create instrument

curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/instruments \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "cap_table_id": "'$CAP_TABLE_ID'",
    "symbol": "CS",
    "instrument_kind": "common_equity",
    "par_value": "0.00001",
    "authorized_units": 10000000
  }'

API — create holder

curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/holders \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Jane Smith",
    "holder_type": "individual",
    "contact_id": "'$JANE_CONTACT_ID'"
  }'

API — issue shares (equity grant)

curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/grants \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "cap_table_id": "'$CAP_TABLE_ID'",
    "instrument_id": "'$INSTRUMENT_ID'",
    "recipient_contact_id": "'$JANE_CONTACT_ID'",
    "recipient_name": "Jane Smith",
    "grant_type": "common_stock",
    "shares": 6000000
  }'

MCP prompt

Issue 6,000,000 common shares to Jane Smith and 4,000,000 to Bob Chen.

---

5. Set up governance

CLI — create a board of directors

corp governance create-body \
  --name "Board of Directors" \
  --body-type board_of_directors \
  --quorum majority \
  --voting-method per_capita

CLI — add board seats

corp governance add-seat \
  --body-id @last \
  --holder-id $JANE_CONTACT_ID \
  --role chair \
  --appointed-date 2026-03-24

corp governance add-seat \
  --body-id @last:body \
  --holder-id $BOB_CONTACT_ID \
  --role member \
  --appointed-date 2026-03-24

CLI — pass a board resolution

For routine approvals, use quick-approve to create a written consent, cast unanimous votes, and adjourn in a single command:

corp governance quick-approve \
  --body-id @last:body \
  --title "Approve Acme AI Inc Formation and Initial Equity" \
  --resolution-text "The Board of Directors hereby approves the formation of Acme AI Inc, a Delaware C-Corporation, and the issuance of 10,000,000 shares of common stock to the founding team as described in the cap table."

API — create governance body

curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/governance/bodies \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Board of Directors",
    "body_type": "board_of_directors",
    "quorum_rule": "majority",
    "voting_method": "per_capita"
  }'

API — add a seat

curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/governance/seats \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "body_id": "'$BODY_ID'",
    "holder_id": "'$JANE_CONTACT_ID'",
    "role": "chair",
    "appointed_date": "2026-03-24",
    "voting_power": 1
  }'

API — quick-approve a resolution

curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/governance/quick-approve \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "body_id": "'$BODY_ID'",
    "title": "Approve Acme AI Inc Formation and Initial Equity",
    "resolution_text": "The Board of Directors hereby approves the formation of Acme AI Inc..."
  }'

MCP prompt

Create a board of directors for Acme AI Inc with Jane Smith as chair and Bob Chen as member. Pass a written consent approving the formation and initial equity issuance.

---

6. Run the intent/decision/receipt lifecycle

For side effects that require explicit authorization — accepting a funding round, executing a share transfer, or any action with legal consequence — the system requires a typed intent, evaluation, authorization, and execution.

CLI

# Create the intent
corp execution create-intent \
  --intent-type "equity.round.accept" \
  --description "Accept seed round term sheet at $5M valuation cap" \
  --authority-tier tier2

# Evaluate (policy check)
corp execution evaluate-intent @last

# Authorize (human sign-off recorded)
corp execution authorize-intent @last

# Execute (state change committed)
corp execution execute-intent @last

API — full intent lifecycle

# 1. Create typed intent
INTENT=$(curl -s -X POST http://localhost:8000/v1/entities/$ENTITY_ID/intents \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "intent_type": "equity.round.accept",
    "description": "Accept seed round term sheet at $5M valuation cap",
    "authority_tier": "tier2",
    "metadata": {}
  }')
INTENT_ID=$(echo $INTENT | jq -r '.intent_id')

# 2. Evaluate
curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/intents/$INTENT_ID/evaluate \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

# 3. Authorize
curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/intents/$INTENT_ID/authorize \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

# 4. Execute
curl -X POST http://localhost:8000/v1/entities/$ENTITY_ID/intents/$INTENT_ID/execute \
  -H "Authorization: Bearer $CORP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

Review receipts and obligations

# CLI
corp execution receipts
corp execution obligations

# API
curl http://localhost:8000/v1/entities/$ENTITY_ID/receipts \
  -H "Authorization: Bearer $CORP_API_KEY"
curl http://localhost:8000/v1/entities/$ENTITY_ID/obligations \
  -H "Authorization: Bearer $CORP_API_KEY"

---

7. Day-to-day operations

Check entity status

corp status              # workspace overview (remote)
corp --local form status @last   # formation status (local)

View pending obligations

corp execution obligations

Inspect the cap table

corp cap-table show                      # active entity
corp cap-table show @last                # same, explicit
corp cap-table grants                    # all equity grants
corp cap-table valuations                # 409A valuations

View governance

corp governance bodies                   # governance bodies
corp governance meetings                 # all meetings
corp governance profile                  # governance profile

Using corp-server call for scripting

corp-server call executes a single API request in-process without a running server — useful for CI scripts that need local-mode access without the corp binary:

corp-server call GET /v1/entities
corp-server call POST /v1/entities '{"legal_name":"Scripted Corp","entity_type":"c_corp","jurisdiction":"DE"}'

Machine-readable output

Add --json to any corp command for structured output suitable for pipelines:

corp --local cap-table show --json | jq '.grants[].shares'
corp --local entities list --json | jq '.[].entity_id'

---

Summary

Stage	CLI command	API path
Form entity	corp form create	POST /v1/entities
Advance formation	corp form advance @last	POST /v1/formations/{id}/advance
Sign document	corp form sign @last	POST /v1/documents/{id}/sign
Confirm filing	corp form confirm-filing @last	POST /v1/formations/{id}/filing/confirm
Confirm EIN	corp form confirm-ein @last	POST /v1/formations/{id}/tax/confirm-ein
Init cap table	corp cap-table init	POST /v1/entities/{id}/cap-table
Create instrument	corp cap-table create-instrument	POST /v1/entities/{id}/instruments
Issue shares	corp cap-table issue	POST /v1/entities/{id}/grants
Create board	corp governance create-body	POST /v1/entities/{id}/governance/bodies
Quick-approve	corp governance quick-approve	POST /v1/entities/{id}/governance/quick-approve
Create intent	corp execution create-intent	POST /v1/entities/{id}/intents
Execute intent	corp execution execute-intent @last	POST /v1/entities/{id}/intents/{id}/execute

All three interfaces — corp CLI, corp-server HTTP API, and MCP tools — share one governance kernel and one git-backed audit trail.