INTERSIGNAL
Braid - shared state for more than one LLM

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 selected context a portable, inspectable form, then lets the receiving system retrieve what matters for a new question while keeping acceptance and local use under its control.

Across devices and models Relevant context, not whole chats Provenance stays visible Conflicts stay visible Receiver keeps control

Your work should survive the model, machine, and session where it began.

People increasingly use several AI systems: one for writing, another for research, another on a local workstation, and perhaps another at a different site. Each may be capable, but each usually begins with its own isolated context. Braid is a shared state layer for carrying forward the facts, constraints, decisions, observations, and relationships that should not have to be explained again from zero.

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

USE_01

Move between devices

Carry selected project context from a laptop to a workstation, home machine, office system, or edge device without rebuilding the entire conversation.

USE_02

Use specialist models

Let one model research, another review, and another act from the same accepted situational foundation while each keeps its own role.

USE_03

Continue across places and time

Keep useful state available when a session ends, a machine goes offline, or work moves between people, rooms, or physical locations.

USE_04

Keep humans and receivers in control

Move evidence and context without treating transport, similarity, or another model's output as automatic authority.

Without shared state
With Braid
A new model or device begins with little or none of the earlier situational context.
Selected accepted context can survive the machine and session where it was created.
People copy prompts, chats, files, and memory bundles by hand.
A bounded portable object carries selected meaning together with its provenance.
Important facts and unrelated material often arrive as one undifferentiated block.
The receiver can retrieve the pieces relevant to the question being asked now.
A successful handoff can be confused with trust or permission.
The receiving node still decides what to accept, retain, and use.

A receiving machine can do more than store another model's notes.

In controlled cross-computer tests, one node sent selected project context to another. The receiving node accepted that context locally, kept where it came from, and later used its own semantic field to rebuild useful context for a new question. The original chat did not have to remain open, and the receiving model did not have to be the same model as the sender.

The second model no longer had to guess

We used an invented project scenario so the receiving model could not know the rules from its training data. The later question was phrased differently from the information that had been transferred.

Cross-node continuity demonstrated
Before the handoff
The second model guessed from incomplete context.

It lacked the project-specific rules and confidently reached the wrong operational conclusion.

After the handoff
The second model could reason from accepted context.

It answered a fresh, differently worded question using state committed on its own machine rather than relying on a continuing chat.

PROOF_01

Fresh questions

The receiving model could use the accepted state later, in a new inference call, after the original exchange had ended.

PROOF_02

Different machines

The behavior was demonstrated across macOS and Linux rather than inside one shared application or one continuing browser session.

PROOF_03

Visible provenance

The receiver retained source material, lineage, acceptance evidence, and separate records of what was retrieved for each question.

The receiver also chose what mattered

In a second test, the incoming state contained project rules, two different values for the same threshold, and an unrelated maintenance note.

Relevant context retrieved locally
What Braid preserved
The relevant rules and both conflicting values remained visible.

The receiver left out the unrelated note, grouped the two threshold claims as a possible disagreement, retained their sources, and built a fresh local context for the question.

What the answer model revealed
A small local model still tried to choose one value.

Because Braid kept the evidence and the generated answer separate and inspectable, the model's mistake was visible. That result directly informed the next generation guardrail.

This is the practical difference between a shared text pad and a shared state layer. A text pad can hold everything. Braid is being built to help a receiving system identify what is relevant now, preserve uncertainty and disagreement, retain provenance, and construct bounded context for its own local model.

FIELD_01

Context survived

Useful project state remained available after leaving the machine and session where it originated.

FIELD_02

Relevant pieces surfaced

The receiving node selected the facts and rules related to the new question.

FIELD_03

Noise stayed out

Unrelated committed material was not added to the generated context merely because it was present.

FIELD_04

Disagreement was not erased

Conflicting values remained inspectable instead of being silently averaged or overwritten.

Current claim boundary: these tests demonstrate bounded cross-node context continuity, receiver-local retrieval, visible provenance, and conflict-preserving evidence. They do not show model weights, hidden activations, KV cache, or a complete mind moving between systems. Completion models remain fallible. Detailed test records and exact artifacts remain available in the research section.

Technical users can reproduce the mechanism now. The one-click experience is still being packaged.

Braid 1.7.0a3 is the current Semantic Field Proof Build candidate. It packages what we learned from the first physical Mac-to-Linux field test, including clearer acceptance reporting, safer proof-mode defaults, repaired inspection, and stronger safeguards around conflicting evidence. It remains engineering software pending the frozen cross-platform test matrix, not a finished consumer workflow.

COMPAT_01

Same completion model?

Not required. The sending and receiving nodes can use different reasoning models because the receiver reasons from explicit accepted material.

COMPAT_02

Same embedding setup?

Recommended for the first run. Matching verified representation settings provide the simplest controlled path while broader interoperability is tested.

COMPAT_03

Different embedding setups?

Supported through receiver-local representation. The receiver can build its own semantic form from authenticated material instead of assuming unrelated vector spaces are identical.

COMPAT_04

Same OS or location?

Not required in principle. Cross-OS behavior has been physically demonstrated; the a3 candidate is now being tested across macOS, Linux, Windows, and varied hardware.

Core mechanism
Physically demonstrated. A receiving machine gained useful project-specific context and applied it in fresh questions after the original exchange ended.
Semantic Field behavior
Demonstrated on Mac to Linux. The receiver retrieved relevant state, excluded unrelated material, preserved a disagreement, and rebuilt context locally without replaying the whole conversation.
Current proof build
1.7.0a3 candidate. Frozen macOS, Linux, Windows, restart, replay, and varied-hardware validation remains the immediate promotion gate.
Development status
Active engineering alpha. Not every planned feature or one-click workflow exists today. Community tests are driving fixes and additions on an almost daily basis during active build cycles.
Technical reproduction
Available now. It currently requires CLI-level installation, local models, trust enrollment, route configuration, and a chosen transport.
User-defined context
Available at the engine and CLI layer. Technical users can create a signed capsule from their own text, send it to an approved receiver, and ask fresh questions against committed state.
One-click packaging
Still in progress for the 1.7 field workflow. Validated installers, automatic model detection, guided pairing, and a paste-or-file transfer experience remain active work.
Universal guarantee
No. Braid can preserve and surface useful context; success still depends on the receiving model's ability to understand and apply it.

Join the active build - with today's capabilities stated plainly.

Braid is moving quickly, but not every planned capability or one-click workflow exists today. Membership places you inside the working feedback loop: a practical degree of direct human support, every Braid software update released during your active membership term, and access to Braid Managed Relays once they are sufficiently hardened for member use.

Build with us as the protocol becomes a product.

The community is already shaping Braid through real installations, reproducible bug reports, livestreams, and cross-node tests. During active engineering cycles, fixes and features are landing on an almost daily basis. Membership supports that work and gives members a human point of contact.

$99per year
MEMBER_01

Human support

Reasonable best-effort help with installation, pairing, test design, bug intake, troubleshooting, and upgrade paths during the membership term.

MEMBER_02

Every software update

Access to all Braid software updates released during your active membership term, including validated installer builds as they become available.

MEMBER_03

Managed Relays when ready

Access to Braid Managed Relays once they are sufficiently hardened and opened for member use, subject to compatibility, capacity, location, fair-use limits, and experimental-service constraints.

MEMBER_04

Community feedback loop

A direct path for reproducible results and feature requests. Not every request will ship, but member experience helps determine engineering priorities.

Membership begins immediately for support and software updates. Managed Relay access begins when a compatible service is ready and separately provisioned for the member.
What membership is - and is not: Membership supports active development, software access, and member services; it is not a claim that every roadmap feature already exists and it does not include a production SLA. Core LAN software and the public research record remain accessible. A Stripe receipt is not itself a relay credential, and relay availability is not guaranteed in every region or configuration.

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 leads with the everyday problem Braid is designed to solve. The materials below preserve how the behavior was tested, what changed during development, 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.