BookingHash · LedgerHash · StockHash (in development)

Operating infrastructure for businesses.

Accordly builds the systems of record a business runs on: a bookings engine and an accounting engine whose every fact is sealed into a SHA-256 hash chain and verified deterministically, built so that people, accounting firms and, in time, AI agents can rely on the record.

Sandboxes run on staging with test data. Production access is by waitlist.

  • Operation
  • Event
  • Canonical payload
  • SHA-256
  • Previous hash
  • Gapless sequence
  • Chain
  • Verification
  • Write-once anchor

One platform. Two engines. One verifiable record of what happened.

Accordly is the parent brand of BookingHash and LedgerHash. StockHash is in development and an MCP layer for AI agents is planned; neither is available yet.

The Accordly platform map

  1. Accordly sits at the centre and links to each engine.
  2. BookingHash, the bookings engine, and LedgerHash, the accounting engine, are available as staging sandboxes.
  3. StockHash is shown with a dashed link because it is in development.
  4. The MCP layer for AI agents is shown with a dashed link because it is planned, not available.

Two engines you can try today in a staging sandbox.

Each engine is a tenant-scoped API. Create an organisation in the Portal, open a sandbox, and your API secret is shown once.

Bookings Sandbox on staging

BookingHash

Availability, holds and bookings with a hash-chained history for every booking. Verify any booking's diary and get a deterministic answer.

  • Request → hold → booking → lifecycle events
  • Idempotent writes with an Idempotency-Key
  • Per-booking history with chainValid

Accounting Sandbox on staging

LedgerHash

Journal entries sealed into a hash chain, periods closed under a Merkle root, inclusion proofs you can verify offline.

  • Sealed journal entries, 2 to 500 lines
  • Closed periods are immutable, enforced in the database
  • Entry inclusion proofs against the period root

Inventory In development

StockHash

A stock and inventory engine on the same record discipline. In development; not available; no date.

From operation to verifiable record.

The same discipline runs through both engines. Nothing is a claim you have to take on trust; it is a digest you can recompute.

  1. Operation

    A hold is placed, a booking is confirmed, a journal entry is posted. The engine records the fact and, in the same database transaction, the event that describes it.

  2. Deterministic digest

    Each event or entry is serialised canonically and hashed with SHA-256 together with the hash that came before it. Same inputs, same digest, every time.

  3. Chained

    Because every digest includes the previous one, records form a chain with a fixed head (GENESIS) and a gapless sequence. The database refuses to rewrite sealed rows.

  4. Verified

    Verification walks the chain and recomputes every hash. An altered record changes its digest and breaks every later link, and the API reports exactly where.

Watch a chain break.

Two illustrations of the real mechanisms. The digests are illustrative; the rules are the ones the engines enforce.

BookingHash: one booking, one chain

Illustrative digests
  1. A request for Room 12 for 2 nights arrives; the availability decision is computed in memory and not stored.
  2. Event 1, hold placed, is sealed with the previous hash GENESIS.
  3. Event 2, booking confirmed, is sealed with the hash of event 1.
  4. Event 3, started, and event 4, completed, follow, each sealed with the previous hash.
  5. Verification walks the chain and recomputes every hash: CHAIN_VALID.
  6. Event 2's payload is altered to 3 nights: its recomputed hash differs, the links after it fail, verification reports CHAIN_BROKEN at sequence 2.

Every event is hashed with the previous hash (SHA-256). Change one, and every later link fails verification.

Optional: a daily digest per tenant can be written to storage with Object Lock in compliance mode (write-once anchoring), enabled per tenant.

LedgerHash: sealed entries, closed periods, inclusion proof

Illustrative digests
  1. Entries 415 to 418 are sealed in sequence; each entry hash is SHA-256 of the canonical payload and the previous hash.
  2. Period P-08 closes: a Merkle tree over the four entry hashes gives the merkle_root; period_hash is SHA-256 of the root and P-07's period hash.
  3. The inclusion proof for entry 418 lists the sibling hashes up to the root; it can be verified offline.
  4. Verification re-derives every payload and finds no mismatch: the period is intact.
  5. Entry 417's amount is altered: its recomputed digest differs, verification reports FINGERPRINT_MISMATCH at posting sequence 417, the Merkle root changes, and P-08 and P-09 period hashes differ.

Entries are sealed with the previous hash; a closed period gets a Merkle root and a period hash chained to the previous period. One altered entry changes the root and every later period hash.

Anchoring of sealed periods to write-once storage is supported.

Planned

Infrastructure for AI agents.

Planned: an Accordly MCP layer that gives AI agents permission-scoped access to BookingHash and LedgerHash through the same Accordly API, with every action landing in the engines' hash-chained records. No release date is published.

How the agent layer is planned to work

How the planned agent layer would work

Planned
  1. The agent sends a request to the planned MCP layer.
  2. The MCP layer calls the Accordly API within the agent's permission scope.
  3. The API performs the operation in BookingHash or LedgerHash; the fact is sealed into the hash chain.
  4. The response returns to the agent with a reference to the sealed record's hash.

Planned. The MCP layer is not available and no release date is published.

Strategy

Accounting firms as partners, not just customers.

Accordly intends to acquire or partner with accounting firms, improve the operations of those firms and their clients, and give both a system of record they can verify. This is stated as strategy and intent; no acquisition or partnership is announced here.

Read the accounting-firm strategy

Security principles, not certificates.

We publish no certification, audit or uptime claims. What we publish are the rules the engines enforce.

  • The key is the address

    An API key identifies the tenant. Only an HMAC-SHA256 of the secret is stored, never the secret; an unknown key receives a uniform 401.

  • Secrets shown once

    A sandbox API secret is displayed once, at creation, and never again.

  • Staging and production are isolated

    Trials provision only in staging. The production platform doors are closed; production access exists only through waitlist onboarding.

  • Server-side only

    The browser never calls an engine. Every engine call is a server-side adapter call made by the Portal.

  • Hash-chained audit

    Every fact writes its event in the same transaction, sealed into a SHA-256 chain that can be verified on demand.

Security and trust in detail

Try it now, or queue for production.

Sandbox on staging

Free sandbox

  • Runs on the staging environment of each engine
  • Test data only; test keys (bh_test_ / lh_test_)
  • API secret shown once at creation
  • May be reset; no availability commitment
  • Created through the Portal after sign-up and organisation creation

Production by waitlist

Production

  • Access by waitlist only
  • Onboarding under a separate agreement
  • No self-serve checkout, no published pricing
  • No release dates published
  • Production platform doors stay closed until then

Questions, answered plainly.

Is the sandbox the same as production?

No. Sandboxes run on the staging environment of each engine with test data and test keys. They may be reset at any time and carry no availability commitment.

How do I get production access?

Through the production waitlist in the Portal. Onboarding and a separate agreement follow; there is no self-serve checkout.

What does it cost?

We have not published pricing. Production terms are agreed during onboarding.

Are the engines built on a public network or tokens?

No. Each engine keeps its own SHA-256 hash chain inside its own PostgreSQL database. Verification is a deterministic recomputation, nothing more.

Can I verify records myself?

Within your tenant, yes. BookingHash returns chainValid with every booking history; LedgerHash's verify endpoints re-derive every payload and report the first mismatch, and its inclusion proofs can be checked offline against the period's Merkle root.

Is anchoring to write-once storage automatic?

BookingHash supports a daily write-once anchor per tenant, enabled per tenant. LedgerHash supports writing anchor records for sealed periods to write-once storage; today that is operator-triggered, not automated.

Where is data stored?

Engine data lives in AWS in the eu-west-2 (London) region. The Portal uses Clerk for authentication. See the privacy notice for the full list of processors.

What about StockHash and the MCP layer?

StockHash is in development and the MCP layer for AI agents is planned. Neither is available and no dates are published.

Start with a sandbox. Move to production when you are ready.

Sign up in the Portal, create an organisation, open a sandbox. When you need production, join the waitlist.

Sandboxes run on staging with test data. Production access is by waitlist.