^_^
press any key to skip
Your AI buddy
^_^ logishell.canvas contract

Your AI buddy that ships verified code.

your repo → verified blocks

Describe what you need in plain words — your buddy turns it into a typed, verified block of real code. Wire blocks on an infinite canvas: the canvas is the program, and every block is proven once, then cached forever.

Request early access See how it works ↓
$curl -fsSL logishell.com | sh
Reads your repo in place · Never rewrites it · Runs on your machine
sampleCartcart.ts
outCart
Tax engineref
regionEU · 19%
computeQuotequote.ts
ComputeDeterministic
in Cart · Customer → Quote
0x6748…1ee9 · verified · cached
quote.testspec
7 casespassed
explainQuotellm
outMarkdown
reviewgate
Probabilistic
verdictapproved
$ logishell run quote ✓ 7 passed · total $23,800 · 0.41s · cachedlogishell.com
tl;dr1say it in plain words→2get a verified block of code→3wire blocks into a product
What you get

Three things, in plain terms.

No new language to learn. Point LogiShell at a repo and it hands back parts you can trust and reuse.

01 · describe

Typed blocks from plain language

Say what an entity or process is. It materializes as a block with declared ports, effects and cost — a contract, before a single line is generated.

spec→^_^draft→contract
02 · verify

Proof, not trust

Every block carries a dual hash — contract + implementation — and a cached review verdict. Verified once, never re-reviewed. You ship the artifact, not your faith in it.

0x6748…+0x2fd8…→verified ✓
03 · compose

Code and canvas, one program

Wire blocks on an infinite plane or edit the same program as code — both views stay in sync. Mismatched ports repair themselves with a synthesized, verified adapter.

blocks⟷code+adapter
The problem

Code generation scaled. Code trust didn't.

LLMs made implementation nearly free — and reuse nearly impossible. Every generated function is a snowflake: no stable interface, no identity, no proof it works. The expensive part of software is no longer writing it. It's trusting what's been written.

spec.md
the ask
model
writes impl #4718
impl #4718
no hash · no identity
human review
queue: 41 waiting
regenerate → re-review → repeat forever

Review is the new wall

Every AI-generated line waits for a human willing to trust it.

Trust evaporates

Generated code has no identity; verified today, anonymous tomorrow.

Code stopped compounding

Teams regenerate and re-review the same logic thousands of times.

Block anatomy

A block is a contract, not code.

computeQuote
ComputeDeterministic
fn computeQuote(LineItem[], Customer) → Quote
in  LineItem[] · CustomerQuote
0x6748…1ee9·verdict: verified·cached
1

Typed ports

Inputs and outputs are declared types — teal in, amber out. Blocks only connect when the types line up.

2

Declared effects & cost

Compute, deterministic, priced. Every capability the block uses is on the contract, in the open.

3

Content-addressed identity

Contract hash + implementation hash + review verdict. The block is what it can be proven to be.

4

Verified once, cached forever

The verdict is keyed by the hash pair. Nothing re-runs a review that already passed.

How it works
01 · Contract

A contract, not code.

Define ports, effects, capabilities and cost — or let the platform draft the contract from your spec. Nothing is generated yet.

02 · Generate

Any model fills it in.

A model writes an implementation to satisfy the contract. Implementations are disposable — the contract is the asset.

03 · Verify

Verified once, cached forever.

AI review checks the code against the contract. The verdict is keyed by the hash pair, so it never re-runs a review that already passed.

04 · Compose

Blocks snap into a program.

Blocks connect by structural port matching. When ports don't fit, an adapter is synthesized and verified — seams repair themselves.

^_^ contract.canvasstep 1/4
sampleCartcart.ts
outCart
Tax engineref
regionEU · 19%
computeQuotequote.ts
ComputeDeterministic
const q = base·seats + taxFor(region)
return { total, currency }
contract · draft0x6748…1ee9 · generating…0x6748…1ee9 · verified · cached
quote.testspec
7 casespassed
explainQuotellm
outMarkdown
Deterministic
DETERMINISTIC
cached · replayed · free to re-run
Probabilistic
PROBABILISTIC
journaled · gated · human-approvable

One boundary runs through everything.

Caching, pricing, review and replay all derive from this one visible line.

Two ways in

Bring a repo. Or bring nothing.

You have a repo

Import it. Everything integrates.

LogiShell reads your repo in place — nothing rewritten, nothing moved. Functions are lifted into typed blocks, your integrations become typed ports, and whatever can be proven is verified and cached on day one.

$ lb import .
▸ 214 files · read in place · 0 rewritten
▸ 41 functions lifted into typed blocks
▸ integrations typed: stripe · slack · postgres
✓ your repo, as a canvas — 28 blocks verified
You have an idea

Solo founder? Skip the plumbing.

Auth, billing, storage and deploy already exist inside as verified blocks. No boilerplate, no glue code, no six-week stack sprint — the boring 80% is pre-proven. You describe the product, wire it, and build the 20% that's actually yours.

$ lb new company
▸ auth · billing · db · deploy — verified blocks, built in
▸ no boilerplate · no glue code · no stack sprint
✓ describe it. wire it. ship it.
Request early accessSee what people build ↓
Describe → materialize

Describe like a child. Verify like an auditor.

prompt
Invoiceentity
idUUID
customerIdUUID
linesLineItem[]
periodDateRange
taxRegionRegion
totalMoney
statusPaymentStatus
issuedAtTimestamp
0x2fd8…f5ecverdict: verifiedcached
entity → design → code → delivered
The stack

IDE → Protocol → Store.

LogiShellcreates blocks

The canvas IDE. Describe, generate and wire typed blocks on an infinite plane — code and canvas, one program.

LogicBlocksmakes them trustworthy

Contracts · dual-hash identity · cached verification. The protocol that turns a generated function into something you can prove.

LogicStoremakes them liquid

Closed source. Open trust.

Sell a verified block without showing source.

“Buyers verify the artifact, not the repo.”
Systems, not snippets

Real systems, assembled from blocks.

Nine live schemes — every one a graph of typed, verified blocks. Deterministic where it can be, gated where it must be. They drift as you scroll; the wires stay typed.

Pricing & quotes6 blocks
sampleCart
out · Cart
Tax engine
ref · EU 19%
computeQuote
✓ verified · cached
Deterministic· verified · cached
Auth & sessions4 blocks
credentials
out · Creds
login
✓ verified
session
stored
Deterministic· verified · audited
Invoicing & tax7 blocks
usage
out · Usage
rates
ref · region
invoice
✓ verified · cached
Deterministic· verified · cached
AI agentsagentic
inbox
out · Msg
^_^ agent
plans · gated
tools
typed
Probabilistic· journaled · gated
Content moderation3 blocks
post
out · Post
classify
p = 0.97
gate
approved
Probabilistic· human-approvable
ETL pipeline5 blocks
ingest
out · Rows
transform
✓ verified
store
replayable
Deterministic· replays free
Integrationsconnectors
Stripe
out · Charge
Slack
out · Event
flow
ports match ✓
Deterministic· ports typed
Internal toolsops
blocks.query
live data
dashboard
wired, not copied
Deterministic· live, not a copy
Support triage4 blocks
ticket
out · Ticket
triage
routes · gated
route
human-ok
Probabilistic· journaled · gated
Why now

Research caught up.

MIT's Recursive Language Models and CodeAct showed the same thing: models do dramatically better exploring a typed environment than swallowing context whole. LogiShell is that environment — typed, content-addressed, auditable.

JSON Schema 2020-12 contracts · MCP-compatible by construction · source-available · no proprietary lock-in
✓protocol core runs today ✓contract v0 — MCP superset →canvas IDE in prototype
Built in the open by a solo technical founder.
Early access

Early access opens in waves.

Developers first. Bring a repo you don't fully trust — or nothing at all.

No spam — one email when your wave opens.
^_^canvas·x 0·y 0·100%·hero.canvas
^_^