INTERSIGNAL
Braid v1.6.0rc2 - cross-node situational continuity

Let one AI node pass useful understanding to another.

If you run more than one LLM - on different computers or in different physical locations - each normally starts with only its own context. Braid lets one node package selected situational state, move it with provenance, and let the receiving node use it later under local control.

Kestrel core proof passed Mac to Linux over WAN Fresh-query recovery 384D + signed meaning Receiver-owned acceptance

The second node changed its answer because it received the missing situation.

In the Kestrel run, a local model on a remote Linux node was asked a question about an invented operating protocol it had never seen. Before Braid, it confidently made the wrong decision. A Mac then sent the missing facts and rules through a public TLS 1.3 relay. After the receiving node accepted and committed that state, the same model answered new questions correctly in fresh inference calls.

Kestrel Run: before and after

The test used made-up names, rules, thresholds, and readings so the answer could not come from model training data. The post-transfer questions were phrased differently from the transmitted text.

Core proof passed
Before Braid
Node B said: do not proceed.

Without the Kestrel policy, the model invented a rule and interpreted readings of 68 and 70 in the wrong direction.

After Braid
Node B said: proceed.

It correctly recovered the two-reading rule, the below-73 threshold, and the requirement that both readings be independently signed by Finch.

PROOF_01

Fresh inference

Both post-transfer answers rebuilt context from committed Braid state. They did not rely on a continuing chat session.

PROOF_02

Real network boundary

The path crossed from macOS to a physically remote Linux node through the relay, then into a loopback-only local receiver and local model.

PROOF_03

Meaning plus provenance

The receiver retained the signed material, a 384D state vector, lineage, acceptance evidence, and separate query records.

Object digest: 5f81e8a4578f4b766644e95c08a26f8e22e82b6ff03bcad87c71b2efd49e08cb. This proves the core A-to-B contextual-hydration result from committed semantic state. It does not claim transfer of model weights, hidden activations, or KV cache; broader release-candidate negative testing remains ongoing.

More than one LLM should not mean starting over every time.

A second model may live on another computer, specialize in another task, or operate in another physical location. Without a shared state layer, useful context often dies where it was created or has to be copied manually. Braid gives that context a portable, inspectable form while leaving each receiver in control.

One LLM can work alone. The moment you have two, continuity becomes infrastructure.

USE_01

Laptop and workstation

Carry selected project state from a mobile machine to a larger local model without recreating the entire conversation.

USE_02

Different physical sites

Let a node at home, in an office, or in the field pass situational updates to another location through an approved path.

USE_03

Specialized models

One model can observe or summarize a situation while another later reasons from the accepted state in its own local environment.

USE_04

Interrupted connectivity

Useful state can remain locally committed and queryable even when the originating node or cloud service is no longer available.

Unbraided
Braid-enabled
A new node begins without the first node's situational context.
Accepted state survives the machine and session where it was created.
Operators copy prompts, transcripts, files, or memory bundles by hand.
A bounded signed capsule carries selected meaning and provenance.
Transport success can be confused with successful ingestion.
The receiving node independently validates, accepts, stores, and records finality.
Different model environments need ad hoc bridges.
The receiver can construct its own local representation from authenticated material.

Technical users can reproduce the mechanism now. The one-click experience is the next packaging layer.

Kestrel was a controlled benchmark, not a hard-coded answer. The scenario was invented so the receiver could not know it in advance; Braid carried the missing state, and the receiver's own local model performed the later reasoning. A technical user can reproduce that class of result today with Braid 1.6.0rc2, local Ollama, an enrolled trust route, and either LAN reachability or Jump Kit.

COMPAT_01

Same completion LLM?

Not required. Node A and Node B can use different reasoning models because the receiver reasons from explicit authenticated material.

COMPAT_02

Same embedding digest?

Recommended for the first run. A matching digest enables the strict exact-space 384D fast path demonstrated by Kestrel.

COMPAT_03

Different embeddings?

Supported through local re-embedding. The receiver builds its own representation from the signed Semantic Capsule rather than pretending unrelated vectors share coordinates.

COMPAT_04

Same OS or location?

Not required. The proof crossed from macOS to remote Linux over TLS 1.3; LAN and optical paths remain available.

Core mechanism
Physically demonstrated. A remote receiver corrected its decision in multiple fresh inference calls after committed state arrived.
Technical reproduction
Available now. It requires CLI-level installation, local models, trust enrollment, route configuration, and a chosen transport.
User-defined text transfer
Available now at the engine/CLI layer. Technical users can create a signed capsule from their own text or UTF-8 text file, send it to an approved receiver, and ask fresh questions against the committed state.
One-click native 1.6
Not yet shipped. Native installers, automatic model detection, guided pairing, and a paste-or-file semantic transfer workflow are the next product milestone.
Universal guarantee
No. Braid supplies missing situational context; success still depends on the receiver model's ability to understand and apply it.

Fund the packaging layer without putting the core LAN protocol behind a wall.

Core Braid LAN software remains free and inspectable. The paid founding tier supports the operational layer around it: managed cross-network reach, guided onboarding, native 1.6 packaging, user-defined semantic transfer, updates, and human support.

From technical proof to reproducible product.

A deliberately small early cohort for local-LLM users who want managed relay access and want to help harden the first practical cross-node situational-continuity workflow.

$99per year
MEMBER_01

Braid Managed Relay

Enrollment for approved member devices during the membership term, subject to experimental capacity and fair-use limits.

MEMBER_02

Native 1.6 updates

Supported installer builds as they clear platform validation, plus release notes and upgrade guidance throughout the year.

MEMBER_03

Your own transfer test

Use your own facts, rules, observations, or project state, then verify that a second node can answer fresh questions from what it accepted.

MEMBER_04

Best-effort support

Priority bug intake, setup guidance, and direct feedback into the protocol's first production-oriented packaging cycle.

Stripe-hosted annual checkout is available. Managed Relay access is provisioned separately after subscription verification.
What the payment gates: managed relay enrollment, supported packaging, onboarding, and member services. It does not revoke public access to the core LAN software or research record. A Stripe receipt is not itself a relay credential; access is provisioned separately after subscription verification. Experimental service, no production SLA.

Braid v1.6.0rc2

The exact Python wheel and full source candidate used for queryable committed state, strict same-space coherence verification, and the novelty-as-evidence policy exercised in the successful Kestrel run. Existing v1.5.2 native installers remain available below while native 1.6 packaging is validated.

Release candidate

After receiver-owned commitment, Braid stores authenticated semantic material beside the receiver-local vector and lineage. Later queries reconstruct a fresh local context from that committed bundle. The rc2 correction distinguishes coherent novel information from malformed or untrusted state without disabling receiver checks.

SHA-256 - braid_client-1.6.0rc2-py3-none-any.whl
f93473c00fd74ba8deb18402f8e27f0f03a73d4be108edfc6c359a89c993744a
SHA-256 - intersignal-braid-light-client-v1.6.0rc2-source-candidate.tar.gz
0bf31ed3888069ff3e3f6685ad5ea794d1a16b03183c04b4c44d7892e7681645

Braid for Apple Silicon

Standalone macOS app in a drag-to-Applications DMG. This native build contains the proven 1.5.2 transport and trust foundation; use the 1.6 wheel above for the new queryable-state workflow.

62.6 MB - arm64
SHA-256 - Braid-1.5.2-macOS-arm64.dmg
385d61ab993de9fa0b47548379818a5dc9e7a8f57f44b7d03ca9091392ed5397

Braid for Windows x64

Download the ZIP, extract the complete folder, and run Install-Braid.cmd. It installs for the current user and includes its own runtime and dependencies.

43.7 MB - x64

Research-build note: Windows may show an unfamiliar-app warning because this release is not code-signed. Verify the SHA-256 below; do not disable Windows security globally.

SHA-256 - Braid-1.5.2-Windows-x64.zip
656bc264dd821af1edac966b982acf6e96275effffc6470a049de8b9111864ff

Braid for Linux

Desktop installer with Braid Client, Braid Visualizer, and Braid Trust enrollment. Physically validated on ASUS Ascent and Lenovo ThinkPad hardware.

Linux - x86_64 / arm64 Python runtime
SHA-256 - Braid-1.5.2-Linux.tar.gz
47952e20fa78382b712caa1fbe81afb7525349099db952eae645d1ee916af853

Braid Managed Relay / Jump Kit 1.5.3rc2

When two approved devices are on different networks, Jump Kit carries the exact signed Braid object through an authenticated TLS 1.3 relay path. The relay changes reach, not authority: the receiving Braid node still decides whether anything is accepted.

Free testing ยท founding tier next

The successful Kestrel run used this path from a Mac sender to a remote Linux receiver. Public testing remains free during the transition. Founding membership adds managed enrollment, guided onboarding, supported packaging, and updates; the relay still cannot create Braid acceptance.

Requirements: Python 3.12 and an installed Braid receiver. This is experimental software, not a production SLA. Do not publish enrollment tokens, private keys, pairing codes, or sensitive .brad objects.

SHA-256 - braid_jumpkit-1.5.3rc2-py3-none-any.whl
a1bf6a92bc1b44726e3c8720695a4b42ba53440d82871d2ce3128de83de7df24
SHA-256 - braid_jumpkit-1.5.3rc2.tar.gz
9a2519d62c70739bb8f68af8390d9f27f9180423969aaf6502e09d27b99c37cd

Selected meaning moves. Control does not.

Braid is not a shared chat window and it does not ask unrelated models to interpret an opaque vector as a universal language. The sender chooses what should become durable. Braid binds explicit semantic material to a compact machine representation and its provenance. The receiver verifies the object, applies local policy, and only then makes the state available to its own model.

STEP_01

Select

An operator or application decides which facts, constraints, observations, or relationships are worth preserving.

STEP_02

Represent and sign

The selected meaning travels with a signed Semantic Capsule and a 384D route representation bound to the same object.

STEP_03

Transport

The same signed object can move over LAN, optical QR, or an approved relay path without the transport layer granting acceptance.

STEP_04

Commit and query

The receiver accepts under local policy, stores material, vector, and lineage, then reconstructs fresh inference context when queried.

NODE ASelected situational meaning + local 384D characterization + signature
BRAID OBJECTBounded material, provenance, route evidence, and exact signed bytes
TRANSPORTLAN, optical QR, or Braid Managed Relay path
NODE BVerify, accept locally, persist, and reconstruct context for fresh queries

Receiver sovereignty

A signed capsule establishes provenance and integrity, not truth or command authority. Transport arrival, semantic similarity, and model output cannot create acceptance. Only the receiving Braid node's own final commit does that.

Braid 1.6 transfers authenticated semantic material and reconstructs it as receiver-local context. It does not transfer transformer hidden activations, model weights, native internal state, or KV cache.

macOS may block the first launch of the v1.5.2 research build.

The current downloadable DMG is not yet distributed through Apple's Developer ID notarization pipeline. Gatekeeper can therefore show that Braid was blocked. You do not need to disable macOS security.

If you see the Apple security warning

Use the one-app exception built into macOS. The wording may vary slightly by version.

Install the appDrag Braid.app into Applications, then try opening it once.
Open Privacy & SecurityGo to System Settings → Privacy & Security.
Choose Open AnywayUse the one-app exception next to the Braid warning.
Confirm onceAuthenticate if requested, then choose Open.
Do not disable Gatekeeper globally. If the expected one-app exception is absent, stop and contact us rather than changing system-wide security settings.

What Braid 1.6 is - and is not

Braid 1.6.0rc2 is experimental research software for moving authenticated situational meaning into durable, queryable receiver-owned state. Native v1.5.2 packages remain available while native 1.6 installers complete physical validation.

Demonstrated resultRemote Node B corrected its decision after receiving committed state
Fresh-query behaviorContext reconstructed from durable receiver state, not chat memory
Primary objectSigned .brad frame with explicit Semantic Capsule
384D roleCompact semantic characterization, route evidence, and compatible exact-space fast path
Heterogeneous pathReceiver-local representation built from authenticated material
Receiver flowQuarantine → validation → local commit → durable query
Transport choicesDirect LAN, optical QR, and authenticated relay path
Not transferredWeights, hidden activations, KV cache, or sender authority
StatusExperimental developer research software

The plain-language result sits on top of an inspectable technical history.

The homepage now leads with what Braid does. The materials below preserve how the result was tested, what changed during the Kestrel run, and where the present claim stops. Earlier native installers remain available because they document the LAN, trust, optical, and cross-OS foundation that preceded queryable state.

RECORD_01

Core Kestrel proof

Before/after result, transport path, object digest, fresh-context flags, and exact claim boundary.

Read proof record

RECORD_02

Formal UAT

The synthetic scenario, control condition, transfer requirements, fresh-query tests, and remaining negative closure steps.

Read UAT

RECORD_03

Novelty correction

Why a valid novel state first failed the old subspace gate, and how rc2 preserved evidence without disabling coherence checks.

Read correction note

RECORD_04

Source and history

Review the exact rc2 patch and the public Braid repository alongside earlier research releases.

View patch · GitHub

Useful intelligence should not die where it was created.

Models, agents, robots, workstations, and edge systems will increasingly operate as independent nodes. They need a way to pass useful situational state without collapsing into one cloud account, one proprietary memory store, or one model-specific session.

Braid is an early semantic state plane for that future: explicit meaning, compact representation, visible provenance, receiver-owned acceptance, and multiple possible paths between machines. Evidence may travel. Authority remains local.