AI-powered smart contract development

From your idea to a formally verified smart contract

Q: Do I need to know Solidity or formal methods?

No. You describe what the contract should do in plain language. The Solidity code and the Lean proofs are produced for you, and you review the logic — not the syntax.

Q: Is this an audit service?

No. OrdoCode builds the contract and proves critical properties as part of creating it, instead of checking someone else's code after the fact. The artifacts are useful input for an audit, but the goal is a trustworthy contract by construction.

Q: What exactly is proven?

The properties listed in the specification, each proven by a machine-checked proof. You see the list of proven properties.

Q: What do I get to keep?

The full project: requirements, specification, Solidity code, tests, and proofs — as downloadable files you own.

Q: How much does it cost?

Pricing is set after beta. Beta participants work with a real use case and help shape the product.

Describe what your smart contract should do. OrdoCode turns your requirements into a precise specification, production-ready Solidity code, automated tests, and formal proofs of the properties that matter most.

Apply for beta See how it works ↓

Requirement

Funds can never leave the vault without the required number of approvals.

vault.spec.mdspecification

Preconditions
  approvals(txId) ≥ threshold

Postconditions
  no balance ever increases
  executed(txId) becomes true

Vault.solsolidity

function execute(uint256 txId) external {
    Transaction storage t = txs[txId];
    require(t.approvals >= threshold, "approvals < threshold");
    require(!t.executed, "already executed");
    t.executed = true;
    (bool ok, ) = t.target.call{value: t.value}(t.data);
    require(ok, "call failed");
}

Proof

No execution below threshold — a key property, machine-checked proven ✓

How it works

Five steps: Describe → Review → Build → Prove → Deploy

An AI coding tool produces an implementation from a prompt. OrdoCode first clarifies your business logic, turns it into a specification you approve, and uses that specification to build and check the smart contract.

01Describe

Tell us what your smart contract should do

You: Describe the business idea, the participants, the rules, and the expected outcome.
OrdoCode: Asks clarifying questions and helps surface the decisions you haven't made yet.
Result: Structured requirements

02Review

Review and approve the contract logic

You: Check that the system understood your business logic correctly, in plain language, and approve it.
OrdoCode: Turns your answers into a precise specification.
Result: Approved specification

03Build

Generate the contract and tests

You: The pipeline runs — you review the result at the next step.
OrdoCode: A multi-agent pipeline generates the Solidity smart contract and an automated test suite.
Result: Production-ready Solidity code and test suite

04Prove

Verify the properties that matter

You: See exactly which properties were checked.
OrdoCode: Formalizes the key properties and builds their proofs in Lean.
Result: A smart contract with tests and formal proofs

05Deploy

Get the code and the evidence

You: Review the finished contract, tests, and proofs — then take it with you.
OrdoCode: Packages the Solidity code, test suite, Lean proofs, and docs as files you own.
Result: Ready to hand off

You define the business logic. OrdoCode handles the technical complexity.

Explore the flow →

Formal verification

Beyond testing: mathematical proof for critical properties

Tests check the scenarios someone thought to write. Formal verification proves that a property holds across the states the model covers. OrdoCode brings both into the smart contract development workflow, so the properties your product depends on are proven, not just sampled.

Property Funds can never leave the contract without the required number of approvals.

Formula ∀ s, tx. approvals(s, tx) < k ⇒ ¬ executed(step(s, tx))

Proof status proven ✓

Scope Key verifiable properties of the contract

Prover Lean 4 · machine-checked mathematical proof

Proofs cover the properties and the model agreed in the specification.

Cambrian

One precise language from specification to implementation

OrdoCode uses Cambrian as its core language for specification and development. It gives the AI agents a precise representation of contract behavior and connects your business rules with the Solidity code and the formal verification — so the specification you approve, the contract you run, and the proofs you get are describing the same thing.

Plain languagetranspile to CambrianSolidity + proofs

Read about Cambrian →

FAQ

Questions before beta

Do I need to know Solidity or formal methods?

No. You describe what the contract should do in plain language. The Solidity code and the Lean proofs are produced for you, and you review the logic — not the syntax.

Is this an audit service?

No. OrdoCode builds the contract and proves critical properties as part of creating it, instead of checking someone else's code after the fact. The artifacts are useful input for an audit, but the goal is a trustworthy contract by construction.

What exactly is proven?

The properties listed in the specification, each proven by a machine-checked proof. You see the list of proven properties.

What do I get to keep?

The full project: requirements, specification, Solidity code, tests, and proofs — as downloadable files you own.

How much does it cost?

Pricing is set after beta. Beta participants work with a real use case and help shape the product.