1. Seeing Another Team's Demo at EVOLVE and Recognizing the Missing Half
During the 20-hour build at EVOLVE in Redwood City, my head was buried inside a very specific failure mode of autonomous software factories: what happens inside a single repository when coding agents pass local unit tests while quietly breaking a downstream invariant two files away, or when multiple agents collide on shared files. That sprint produced DEADBOLT, an import-frozen policy floor and 2-hop WebAssembly Tree-sitter blast-radius gate built on top of my pre-audited @krusch/toolkit runtime bricks.
Then final demos started, and I watched Anushka Jogalekar (0xANUSHKA) and Connor Hood (SocialAcolyte) present Common Ground (github.com/0xANUSHKA/common-ground-8090 · common-ground-theta.vercel.app), which earned 2nd Place overall. Framed as "an ontological software factory for venture portfolios," their system lets an engineer build a tool against a shared data standard rather than one company's private column names, verify it across seven immutable checks (including a bounded 3-attempt repair loop and a QuickJS/WebAssembly sandbox tested on public NOAA ocean and NREL solar telemetry), share it by name under fund and company rules, and rebind binding.json locally in VS Code or Cursor without ever uploading private company data or auto-executing downloaded code.
In their own architecture notes, Anushka and Connor explicitly scoped their 20-hour sprint with admirable engineering honesty: "The current factory builds one bounded telemetry-checking function; arbitrary repositories are not supported." Sitting in the audience, that boundary made the synthesis click immediately. My Golden Bricks and DEADBOLT gates already operated across arbitrary repositories (10 languages, <1ms static Slop-Breaker rules, and 2-hop AST blast-radius cones), while Common Ground nailed the exact cross-organization contract rebinding, pre-discovery permission checks, and explainable workflow-brief matching that a single-author library lacks. Put those two halves together, and a toolkit becomes a collaborative codebase where verified bricks travel safely across engineers, portfolio companies, and parallel multi-agent swarms.
2. What Makes the MIT License Special When Builders Meet
People often talk about open-source licenses as dry legal text you pick from a dropdown when initializing a GitHub repository. In practice, the license you choose determines whether good engineering ideas compound or die in isolation after demo day.
When a project has no license (which under copyright law defaults to all-rights-reserved) or sits behind heavy copyleft and commercial-restriction clauses, seeing a brilliant pattern in another team's demo creates an immediate wall. You either walk away and spend weeks reinventing a pale imitation from memory, or you stall waiting on permission before writing a single line of integration code.
Because Anushka and Connor published 0xANUSHKA/common-ground-8090 under the MIT License, and because my own repositories (@krusch/toolkit, krusch-stack, and DEADBOLT) are also MIT licensed, three things happened naturally instead:
- Immediate Architectural Composition Without Friction: Within hours of EVOLVE wrapping up, I could read Common Ground's actual state-model and grant semantics, generalize those concepts from domain-specific telemetry scripts to arbitrary zero-dependency JavaScript and TypeScript runtime bricks, and fuse them directly with DEADBOLT's 2-hop AST dependency analyzer.
- Permanent, First-Class Attribution Built Into the Code: MIT's single core condition is preserving copyright and license notices. Rather than burying inspiration in a footnote,
@krusch/toolkit/brick-exchangeembeds explicit MIT attribution to0xANUSHKA/common-ground-8090and its authors directly inside the module docblocks, specification contracts, and README documentation. Credit travels everywhere the package travels. - Collaboration Grounded in Working Code (Without Claiming Prior Endorsement): Instead of sending a vague note saying "cool demo, maybe collaborate someday," MIT let me build and test an independent clean-room extension first, state clearly what comes from Common Ground versus what I generalized for arbitrary repositories, and reach out to Anushka and Connor with passing code already honoring their work.
@krusch/toolkit/brick-exchange.3. Architectural Synthesis: Where Each Idea Made the Other Stronger
Neither system had to be bolted on awkwardly; each filled a structural blind spot in the other. The table below maps what came from Common Ground, what came from DEADBOLT and @krusch/toolkit, and what emerged when the two designs met:
| Engineering Dimension | Common Ground (MIT) Inspiration | DEADBOLT + @krusch/toolkit (MIT) | Fused Capability in brick-exchange |
|---|---|---|---|
| Verification Rigor | QuickJS/WASM sandbox (32 MB, 800 ms, zero I/O) + 7 checks & 3-attempt repair loop |
<1ms 16-rule Slop Breaker + Node 22 --permission jail + Zero-Leak scanner |
4-Gate Arbitrary-Brick Sandbox + Mandatory Fault Challenges (runBrickVerificationGates) |
| Provenance & Trust | Immutable SHA-256 artifact hash tying source, binding, and check record | Tamper-evident SHA-256 / HMAC SQLite audit-log chains |
Ed25519 Cryptographic Signatures over { blueprintHash, contractHash, sourceHash, checksHash } |
| Discovery & Sharing | Permission-checked recommendations from shared workflow briefs + policy-scoped HydraDB v2 | SQLite FTS5/BM25 + HydraScope OpenCypher graph + Jean SRE Rule-of-3 scout | 2-Tier Team Commons + Federated Grants with permission-scoped HydraDB boost & auto-staged scout specs |
| Repo Adoption & Multi-Agent Safety | Byte-identical source delivery + recipient-local binding.json rebinding (zero auto-exec) |
2-hop AST call-graph blast radius + import-frozen Policy Floor + lockfile checks | Vendored bricks/<id>/ + .brick-lock.json + planAgentFanOut & verifyTwoHopBlastRadius |
4. Inside @krusch/toolkit/brick-exchange: 4-Gate Sealing, Scoped Grants & Lockfiles
To make this workflow practical for everyday engineering teams without requiring any external SaaS account or npm registry setup, I built @krusch/toolkit/brick-exchange (and its zero-dependency twin inside krusch-stack/brick-exchange) around four concrete mechanisms:
- Zero-Ambient-I/O & Mandatory Fault-Injection Sandbox (
sandbox.js): Before a brick can be sealed,scanBrickSourceSafetyrejects ambient network, filesystem, child-process, environment-variable, and dynamic-code imports alongside private IP or secret leaks, strips TypeScript types natively on Node 22, and runs the brick inside an isolated child process with--permissionand--disallow-code-generation-from-stringsplus a lockedvmcontext. Crucially, Gate 4 refuses to seal any brick that only tests the happy path: every brick must pass at least one adversarial fault-injection vector proving it fails closed cleanly on malformed or boundary inputs. - Ed25519 Cryptographic Lineage Seals (
seal-and-policy.js): Passing all four gates produces a deterministickrusch-sealed-brick/v1bundle whose canonicallineagerecord (blueprintHash,contractHash,sourceHash, andchecksHash) is signed with an Ed25519 private key. Changing even a single comment character in a shared bundle invalidatesverifyBrickBundleimmediately. - Two-Tier Visibility: Frictionless Team Commons + Scoped Cross-Org Grants (
store-and-matcher.js): Inside a single team (receiveMode: "team"), published bricks appear immediately in teammates' and subagents' inboxes. Across separate organizations (receiveMode: "federated"), discovery is strictly permission-pre-filtered: an external peer sees zero metadata until an authorized exporter issues a time-bounded, revocableGrant(reshareAllowed: false). Recipients test the sealed brick against their own private data locally viatryBrickLocallyso raw company data never leaves their machine. - Immutable Vendoring &
.brick-lock.jsonDrift Auditing: Runningkrusch-lego adoptwrites the verified brick tobricks/<id>/index.js, generates an editable local adapter atbricks/<id>/binding.jsfor repo-specific column names or thresholds, and records cryptographic hashes in.brick-lock.json. Whenever a developer or CI pipeline runskrusch-lego audit(or when Jean SRE sweeps a repository),auditRepoBrickLocksflags any unsealed local tampering on a vendored brick.
# 1. Generate an Ed25519 signing keypair and seal a TypeScript or JavaScript brick
node bin/krusch-lego.js keygen --out ./keys
node bin/krusch-lego.js seal ./brick-spec.json --key ./keys/brick-signing.key.pem --out ./sealed-brick.json
# 2. Verify the Ed25519 seal, test locally against private input, then vendor + lock it
node bin/krusch-lego.js verify ./sealed-brick.json --pub-key ./keys/brick-signing.pub.pem
node bin/krusch-lego.js try ./sealed-brick.json --input ./private-sample.json
node bin/krusch-lego.js adopt ./sealed-brick.json ./my-service
# 3. Verify zero boilerplate AND zero .brick-lock.json drift in <1ms
node bin/krusch-lego.js audit ./my-service --json
5. Why Validated Bricks + DEADBOLT 2-Hop AST Cones Fix Parallel Multi-Agent Fan-Out
The place where engineering teams feel AI coding pain most acutely right now is parallel multi-agent fan-out. Spawning four coding subagents in parallel sounds fast until they all finish twenty seconds later: Agent A and Agent B each invented slightly incompatible retry helpers, Agent C edited package.json at the same time as Agent D, and Agent B changed a return shape in a utility file that silently broke a billing reconciler two imports away.
Combining Common Ground's sealed bricks with DEADBOLT's 2-hop AST graph turns parallel fan-out into a deterministic engineering workflow:
- Shared Sealed Primitives Instead of Divergent Helpers: Subagents query the local Brick Exchange (via CLI or the 10-tool MCP server) and adopt the exact same Ed25519-sealed bricks instead of improvising four conflicting utility files.
- Disjoint 2-Hop AST Waves (
planAgentFanOut): Given a list of candidate tasks,krusch-lego fanoutparses the repository's import and export graph, computes the 1-hop and 2-hop caller cones for every target file, caps each worker lease at<= 2disjoint files, sequences overlapping 2-hop cones into ordered waves, and isolates shared choke points (server.js,index.js,App.jsx,package.json) strictly for the parent orchestrator. - Pre-Apply 2-Hop Verification (
verifyTwoHopBlastRadius): Before any subagent diff is promoted from staging,verifyTwoHopBlastRadiusblocks out-of-lease file edits, blocks mutations to Policy FloorprotectedFiles, verifies that exported symbols expected by 1-hop and 2-hop callers remain intact, and runs 2-hop neighborhood tests inside a least-privilege Node--permissionsandbox.
| Workflow Baseline | Cross-Org Data Boundary | 4-Agent Parallel Fan-Out Behavior | Measured Local Overhead (Node 22) | Where It Fits Best |
|---|---|---|---|---|
Plain Monorepo Workspace (npm workspaces + lockfile) |
Requires shared repo or private registry read access | Enforces package versions, but blind to intra-repo 2-hop cone collisions & duplicate agent helpers | 0 ms extra tooling |
Single-org human teams with stable package boundaries |
Unguarded Parallel Subagents (4 concurrent workers) |
None (raw prompt context) | Collides on server.js/package.json, invents divergent helpers, & misses +1¢ 2-hop SOX drift |
0 ms upfront; high merge rework |
Throwaway single-developer prototypes |
brick-exchange + planAgentFanOut (v1.8.1) |
Pre-filtered Grants + local binding.js (0 private rows uploaded) |
Reserves choke points (index.js, server.js), orders overlapping 2-hop cones, & flags BROKEN_AST_EXPORT |
~194 ms 4-gate seal · 1.4 ms Ed25519 verify · 0.6 ms lock audit · ~127 ms 183-file wave plan |
Cross-org code sharing & parallel multi-agent coding workflows |
1. Multi-Squad Shared Primitives
Platform engineers seal auth, webhook, and pagination bricks once; product squads adapt local column names in binding.js while .brick-lock.json flags unreviewed edits to vendored security code in <1 ms.
2. Zero-Upload Partner Exchange
Partner teams exchange contract-checked normalizers and integer-cent fee allocators under revocable grants without granting monorepo access or uploading sample customer payloads.
3. Conflict-Free Subagent Waves
Agent orchestrators partition multi-file refactors with planAgentFanOut (~127 ms across 183 files in lib/) and gate promotion on verifyTwoHopBlastRadius (<4 ms static AST check).
6. Scope Boundaries, Limitations & When Standard Monorepos Are Enough
Packaging code signing, 4-gate child-process sandboxes, scoped grants, and 2-hop AST dependency cones introduces real moving parts. Rather than treating brick-exchange as a universal replacement for standard package managers, it is important to state its exact engineering boundaries:
- When Plain Monorepos and Private npm Scopes Are Simpler: If a single human team works inside one trusted repository without cross-organization privacy boundaries or parallel AI subagents, standard
npmorpnpmworkspaces,CODEOWNERS, and normal CI pipelines are simpler to run and maintain.brick-exchangeonly earns its complexity when code crosses trust boundaries without data sharing or when parallel coding agents repeatedly regenerate and collide on shared logic. - 2-Hop Static AST Horizon & Dynamic Dispatch:
extractRepoAstGraphandanalyzeBrickBlastRadiusintentionally bound static traversal at two caller hops (hop0 -> hop1 -> hop2) to keep planning deterministic and sub-150 mson medium packages. Static import graphs do not resolve runtime-computedimport(dynamicExpr)specifiers, reflection, dependency-injection containers, or3+-hop behavioral side effects unless paired with an explicit sandboxedinvariantScriptor full integration test suite. - Cryptographic Provenance vs. Formal Semantic Proof & License Review: An Ed25519 signature over
{ blueprintHash, contractHash, sourceHash, checksHash }proves byte-exact integrity and attests that Gates 1 through 4 passed on the supplied positive and fault-injection vectors. It is not a formal correctness proof over untested input domains, nor does cryptographic sealing verify that an author had legal rights to third-party code they chose to sign. - Key, Grant & Organizational Governance: Federated
Grants and pinned Ed25519 public keys solve the technical data-boundary problem without centralizing private payloads, but participating companies still own key rotation, revocation hygiene, corporate IP/NDA sign-off, semantic schema governance, and long-term maintenance ownership across organizational lines. - Early Validation Status (Design & Reference Implementation): Novelty here is deliberately compositional: combining established primitives (Ed25519 signing, lockfiles, permission sandboxes, and static call-graph cones) specifically for multi-agent and cross-team reuse. Readers can inspect the exact adversarial fault-injection, 1-character tamper, grant revocation, and 2-hop SOX
+1¢assertions directly intest_brick_exchange.js(part of@krusch/toolkit's170/170Node tests alongsidekrusch-stack's73/73tests); collaboration outreach sent to Common Ground's creators received generous encouragement to iterate freely under MIT, while external multi-organization production deployments and independent third-party security audits do not exist yet.
7. Run the Brick Exchange Console, CLI & MCP Server Locally
Both @krusch/toolkit (v1.8.1, 40 runtime bricks, 170/170 Node tests) and krusch-stack (v1.1.0, 73/73 tests) are available under the MIT License, with full credit to Anushka Jogalekar and Connor Hood's MIT-licensed 0xANUSHKA/common-ground-8090 for inspiring the cross-org grant and contract-exchange layer:
git clone https://github.com/kruschdev/toolkit.git
cd toolkit
PUPPETEER_SKIP_DOWNLOAD=true npm install
npm test
# Launch the local Reuse & Grants Web Console on http://127.0.0.1:4318
node bin/krusch-lego.js hub --db ./exchange.db --port 4318
# Or compute conflict-free 2-hop multi-agent fan-out waves on any repository
node bin/krusch-lego.js fanout ./tasks.json /path/to/repo --json