Contributing

The legal model exists to keep the open core sustainable, not to slow you down. Most contributions need nothing more than a Signed-off-by line.

The license model

The stack is split, and so is the contribution model:

• MIT areas — the CLI, the SDKs, the kit, the evals, the extension, the wire contracts, and the provider catalog — use inbound = outbound MIT. Your contribution is MIT; that's the whole agreement.
• BSL areas — the engine, proxy, MCP, shrink, the cavemem Go core, and shared/platform — require two things: a DCO sign-off and a relicense grant to the Licensor (Julius Brussee), so commercial and OEM licenses can include community contributions. The BSL engine is dual-licensed for OEM; the grant is what makes that possible.

There is no full CLA. The relicense grant is the lightweight alternative.

The DCO

The DCO is the Developer Certificate of Origin. You assert you wrote the change (or have the right to submit it) by adding one trailer to each commit:

Signed-off-by: Your Name <you@example.com>

git commit -s adds it for you.

First useful contribution

If you want a small change that matters, write a new content-type compressor for the engine. The engine detects a payload's type and routes it to a safety-classed compressor; a new compressor teaches it to shrink a kind of content it does not yet handle well.

Build and test

The stack is three toolchains. Each has a one-liner:

go test ./...     # the Go services, engine, proxy, and shared platform
pnpm -r test      # the TypeScript packages (CLI, SDKs, evals, kit, web)
pytest            # the Python optimizer and the Python SDK

Run the slice your change touches; the CI runs all three.

The boundary rule

There is one hard architectural rule, and it is enforced:

make check-boundaries

What new code is expected to do

Two honesty invariants bind new code everywhere in the open stack, the same way they bind the existing code:

• Byte-safe. A transform never alters model-visible bytes on a problem. Compressors and the proxy pass the original bytes through unchanged on a parse failure, in record mode, or whenever the result is not smaller. The safe path is always "forward what we were given."
• Fail closed. Unknown enum cases resolve to the conservative answer, not the optimistic one — an unknown mode becomes record, an unknown grader returns passed: false, an unknown wire protocol fails the compile. When in doubt, prefer the honest negative.

Everything public local tools report is inferred: a local estimate, never verified and never re-projected into a monthly figure.

Your first PR

Where to go next