One institution-owned AI endpoint. Every approved tool calls it. Student, patient, and citizen records never leave your boundary, and every accepted output is signed and replayable.
“Is it time to bring your own AI?
A provost described the problem clearly: every SaaS vendor charges per-seat for AI wrapped around someone else's model. An institution with 25,000 students can pay $2,000,000 a year for a single AI-enabled tool. Then $2,500,000 for another. Then $1,500,000 for a third. Each tool does essentially one thing. Each reaches out to the same underlying model capability. The cost is duplicated, and the data leaves the institution on every call.
One institution. 25,000 students. Four AI-enabled tools , a writing tutor, an advising bot, a research assistant, a proctoring reviewer. Every vendor charges a seat license that includes “AI inference” as a line item.
Same underlying model capability. Four vendors. No ownership. No audit trail. Student data egressing to four different inference endpoints. FERPA compliance negotiated separately with each vendor. IT budget crushed.
This is an unsustainable model. Is bringing your own AI something we will need vendors to adopt? Sell us the tool and we plug in the institutional model for AI?”
, A provost, 2026Blockie runs inside the institution too. Ask about cost, compliance, pilot steps, or how students earn. Same assistant that runs locally inside Blockie Talkie deployments, connected here to a public-safe version.
Proofnet AI is a sovereign local reasoning model that runs on the institution's own hardware. It reads and writes through Memory Blocks , an identity-bound, deterministic record layer the institution fully owns. The operator interface is Blockie Talkie, a mesh-ready desktop app with voice, secure messaging, and an Elliott AI assistant. Every AI output is auditable back to the signer of every record it reasoned over.
Vendors don't sell you the AI. Vendors sell you the thin tool that speaks to your AI. You pay for the deployment once.
Sovereign local reasoning model. Runs on institutional hardware. No hosted API, no data egress, no per-seat inference fee. Drop-in HTTP inference endpoint for vendor integrations.
Deterministic, identity-bound record layer. Every document, transcript, advising note, research query, and AI response becomes a signed row. The institution owns the data. The AI reasons over rows you control.
Operator desktop app. Mesh messaging between staff, payment QR codes, local voice input and output, and Elliott AI assistant wired directly to Proofnet AI over the local record layer. No servers required.
Every record and every AI output is bound to the signer's identity , student, faculty, advisor, clinician , through whichever identity system the institution already runs. FERPA and HIPAA-friendly by construction.
The architecture below is what actually ships. SaaS vendors sit outside your institution and integrate through a single local endpoint. The AI, the record layer, the operator interface, and the identity bridge all live inside the institutional boundary. No student data crosses it.
This demo is modeled from the Blockie Talkie app in the repo: a Tauri desktop console with AI Group, Elliott local AI, mesh mail, voice status, wallet/payment approval, agent wall, and a Ledger tab for attestos and Memory Blocks.
Pick a scenario and watch the same institutional model answer through Blockie Talkie, bind the output to identity, write the Memory Block evidence, and leave a packet that IT, faculty, compliance, and procurement can all read.
Presenter macOS app, local operator console, voice-ready assistant, and btalkie:// handoff.
Institution-owned model endpoint that tools call instead of sending records to hosted SaaS AI.
Source rows, AI outputs, approvals, and replay packets remain under institutional control.
Students, faculty, advisors, service accounts, and reviewers can be bound to accepted records.
The demo asks what left the boundary, who approved the answer, and what evidence is replayable.
Show one deployment serving multiple tools so procurement sees reduced duplicated AI spend.
AI Group thread with local inference and signed output.
This tour gives educators a clear walkthrough while still showing IT the real shape: local AI endpoint, approved records, identity binding, signed Memory Block output, and optional external timestamping.
Share link: proofnetbtc.com/blockie-tourThe school is already paying for AI inside many different tools. Blockie Talkie shows one shared institutional AI lane instead of buying the same model repeatedly.
Faculty and staff keep using useful tools, but the AI boundary belongs to the institution.
Approved tools call an institution-controlled OpenAI-compatible endpoint and receive a signed audit packet.
The browser can run the same guided prompt through the website's Blockie AI. This lets a remote reviewer experience the demo even when the local macOS app is not installed.
Ready. Choose a prompt, then click "Ask web AI".
The guided prompt can run through the public web AI for visitors, or be loaded into the local BlockieTalkie.app on a presenter machine for the full desktop handoff.
These are the questions the demo is designed to answer in the room for provosts, CIOs, faculty, compliance, procurement, and technical reviewers.
Use these as the presenter path when an educator or institution asks for proof, policy shape, or next steps.
The review spread above is safe fixture evidence. On a presenter machine with Blockie Talkie open, this bridge checks the local desktop API and can load the Sovereign AI pilot prompt into the app for a real handoff.
The installed presenter build opens through the btalkie:// URL scheme, checks the local desktop API at 127.0.0.1:8099, and can receive a prepared Sovereign AI pilot prompt without sending it automatically.
Loading Blockie Talkie app manifest...
Ready. Click "Check local app" while Blockie Talkie is running on this Mac.
Cheap AI is the easy story. The harder story is that the records every institution signs today, transcripts, credentials, research, patient charts, will stop being verifiable within the next decade. A sufficiently capable quantum computer breaks the digital signatures we all rely on now. When that happens, the transcript you signed last year stops being provable to anyone.
Proofnet signs records under post-quantum cryptography from day one and keeps them in its own record layer, Memory Blocks. The signature still verifies a decade from now, whether or not the original vendor, certificate authority, or identity service is still running. And because every record is tied to the person who generated it, students carry verifiable proof of their own work forever, not rented access to a vendor's dashboard.
Proofnet uses the NIST-final post-quantum primitives and nothing experimental. These are the same families federal agencies are mandated to migrate to under CNSA 2.0 and OMB M-23-02.
Classical algorithms (RSA, ECDSA, Ed25519) still work where an existing adapter requires them. The Proofnet signature over each record is always post-quantum.
Two entities, one clean boundary. The open protocol is free to audit, run, and extend. The production implementations are commercial so one company is accountable for engineering, support, and deployment outcomes.
Specification for record shape, digest family, signature primitive, row commitment, and block sealing. Permissionless. Documentation and reference implementations are free.
AttestoBind, Memory Blocks, AttestoScript, BTCore, PQTLS, Toshi PQ1. Licensed with support contracts, SLAs, and enterprise or government deployment scoping.
A procurement team reviewing Proofnet signs with Blockie Talkie LLC for the implementation. The underlying protocol remains independently verifiable at any time.
When a student's coursework, credential, tutoring session, research contribution, or published artifact lives as an identity-bound attesto in Memory Blocks , signed under the student's own post-quantum key , the student can do things no SaaS dashboard allows:
Transfer, graduate, or apply for a job and hand over a verifiable packet directly. No registrar bottleneck. No vendor portal.
Proof-of-knowledge attestations: a student who mentored another earns a signed record. Paid in Bitcoin through Blockie Talkie payment QR. Auditable.
Opt in and let Proofnet AI learn from your verified records. The attribution is permanent , every model output that cited your work can be traced back and compensated.
Every dataset contribution, lab result, and paper revision lands as a signed attesto. Priority disputes evaporate. Authorship is post-quantum verifiable.
This is what the per-seat SaaS model takes away: in the SaaS model, the student's work and the AI's response to it live inside the vendor's database. The institution rents it. The student has no asset. In the Proofnet model, every record is signed by the student, stored in Memory Blocks the institution owns, and the student carries verifiable proof of everything they did , for life, under post-quantum cryptography.
The per-seat AI question was really a deeper question. Who owns the student's record? Who owns the AI trace? Who still has verifiable proof of what happened here in twenty years, after the vendors, the providers, and the classical signatures are gone?”
, The real answerTwo design choices matter here. First, Memory Blocks don't store raw student work, patient charts, or research drafts. They store the cryptographic fingerprint of those artifacts plus the attestation that an identity-bound actor produced, approved, or verified them. Second, every institution that runs Proofnet adds capacity, redundancy, and witness depth to the shared record layer, which makes records harder to lose and faster to verify over time.
A knowledge attesto is a signed statement of the form: this identity attests that this exact content, digested to this SHA3-512 value, was produced, reviewed, or approved at this moment. The raw artifact, the essay draft, the lab notebook, the DICOM scan, the contract PDF, stays inside the institution's own storage.
The Memory Block row carries the digest, the identity binding, the ML-DSA-87 signature, and any relationships to other attestos, what advisor approved it, what policy applied, what earlier record it builds on. Years later, anyone can re-hash the artifact locally, compare it to the digest in the block, and prove it is the same file the institution attested to. No central vendor, no external index, no raw content egress.
A Proofnet deployment starts inside a single institution. The first Memory Blocks are local: one campus, one hospital, one agency. As trusted peers join, for example a peer university the registrar accepts transfer credit from, or a partner research group co-authoring publications, they run their own Proofnet node and begin replicating relevant attestos across the shared layer.
Three things improve automatically. Records are harder to lose because multiple institutions hold copies of the block headers and can verify any cited attesto. Cross-institution verification becomes instant because the receiving institution already trusts the signer's identity under the shared adapter framework. And the cost of running the network goes down per participant because capacity and witness depth are shared, not duplicated.
Every compliance-regulated institution with 10,000+ users hits the same wall: per-seat AI pricing plus data egress makes the economics and the policy untenable. Sovereign deployment is the answer in all four.
Student records, learning analytics, research data , none of it should egress to a vendor's inference API. Sovereign AI keeps the boundary where the policy assumes it is.
Clinical notes, imaging review, patient chat. Per-query inference to a SaaS vendor is a disclosure event. Local deployment with identity-bound records makes the audit trail real.
Federal, state, and municipal agencies increasingly mandate in-boundary inference. Proofnet AI runs on agency hardware under agency identity, with every decision trace signed and replayable.
Your proprietary data is your moat. Feeding it to a vendor's inference API is giving the moat away. Sovereign deployment keeps the training signal and the inference trail inside your walls.
One hour with your IT, compliance, and academic or clinical lead to define the use cases, the identity system, and the hardware profile.
Proofnet AI + Memory Blocks + Blockie Talkie stand up on your hardware. Identity is bridged through AttestoBind to your existing system (SSO, SPIFFE, X.509, whatever you run).
Point one SaaS tool at the local HTTP inference endpoint. Run it in parallel with the vendor's hosted AI for a week. Measure cost, latency, and audit.
Fold in additional tools. Each new integration reuses the same deployment and the same record layer. No additional per-seat cost per tool.
Public readers can understand the economics here. Approved technical and education reviewers can use the private demo login to inspect the pilot walkthrough and audit packet.
Per-seat AI economics, data boundary, Q-day durability, and student-owned records.
Clickable app replica with live website AI, operator tabs, endpoint view, and proof packet.
Cloudflare Access-gated Sovereign AI pilot packet, local endpoint shape, and audit spread.
Submit organization, role, use case, scale, and timeline for a scoped review room.
Plain answers for faculty, provosts, CIOs, compliance leads, and procurement teams.
AttestoBind, Memory Blocks, post-quantum signatures, and replayable proof packets.
Use this section as the forwardable plain-language FAQ for provosts, CIOs, faculty, IT, compliance, procurement, and pilot sponsors.
It means the institution owns the AI boundary. Instead of each SaaS vendor selling a separate hosted AI layer, vendors call the institution's local Proofnet AI endpoint. The tool can still be vendor-built; the model, records, and audit trail stay institution-controlled.
No. The clean commercial model is that vendors sell the workflow tool and the institution supplies the AI endpoint. A writing tutor, advising system, research assistant, or review tool can point at the same local model and record layer.
The deployment pattern keeps inference inside the institutional boundary. Source records and AI outputs are written as Memory Block rows the institution controls. A production pilot still goes through the institution's normal FERPA, HIPAA, FedRAMP, or internal policy review.
Each accepted source row and AI output can be identity-bound with AttestoBind, digested with SHA3-512, signed under ML-DSA-87, and stored as a replayable Memory Block record. Later, reviewers can see what records were used and who accepted the output.
No. Memory Blocks are the native Proofnet record layer. Bitcoin anchoring is optional external timestamping when a client wants durable public settlement. The institution can start with Memory Blocks only.
Coursework, tutoring, peer review, research contributions, and credentials can become signed attestations tied to the student's identity. That makes the record portable, replayable, and usable for proof-of-knowledge or contribution payments.
The first pilot scopes one tool, one records domain, and one hardware profile. Smaller pilots can begin with a local server or workstation-class deployment; larger institutions can move to managed on-premise infrastructure after the proof path is validated.
The private room is a Cloudflare Access-gated review packet for approved reviewers. It shows the local endpoint shape, Memory Block audit packet, verification spread, pilot checklist, and downloadable brief without exposing model weights, private keys, student data, or production credentials.