Shape-aware compression
Choose different transforms for inputs such as JSON, code, logs, test reports and diffs. Some transforms require explicit selection.
Caveman Engine
Caveman Engine compresses the data a model reads, such as logs, JSON and diffs, and preserves original bytes for recovery when a shorter result discards detail.
Test whether compressed logs preserve the right diagnosis
Use Caveman Engine’s compression and recovery pattern to compare the same incident evidence in raw and compact form.
Describe a sanitized sample, the expected diagnosis and the exact lines required to verify it.
Copy the request into a new Floatboat conversation and provide the required material.
Download FloatboatYour request for Floatboat
Preview and copy the request. It is not sent automatically from this page.
Reference: Caveman Engine https://github.com/juliusbrussee/caveman Read the original documentation and check the current environment and dependencies. Propose any new installation or tool connection before proceeding. My task: Read the Caveman Engine docs. Design a comparison on a sanitized CI log with a network failure and a secondary error. Specify how to recover the original lines, which diagnosis must stay stable and how to record inferred tokens separately from provider usage. Expected deliverable: A comparison plan with a raw baseline, recovery checks and separate local and provider measurement fields.
What Caveman Engine compresses and preserves
An agent often reads the same long logs, diffs or structured output while investigating a problem. Caveman Engine is a local Go library and runtime that detects the shape of incoming data and selects a matching transform. It addresses the context the model reads. The separate Caveman Skill changes how the agent writes its response.
The compact representation can omit detail. Before emitting a lossy result, the engine requires a recoverable copy of the original. It returns the source bytes on unsuitable inputs, invalid or larger results, or recovery storage failure. Local token estimates can help compare candidates, while provider usage and invoices remain separate evidence.
For a Floatboat workflow, use the engine as a reference for preserving originals behind short evidence excerpts. Compare an uncompressed baseline with a compressed run on the same task, recover a specific omitted detail on demand and check that both runs reach the same substantive decision.
How the engine keeps originals available
Inspect the input, the compact result and the recovery path together. A shorter result has value when the agent can still retrieve what it needs to make or verify a decision.
Exact source recovery
Keep original bytes before emitting a lossy replacement, and retrieve them through a recovery handle when the compact result is insufficient.
Pass-through and local measurement
Keep original bytes when no safe, smaller result is available. Compare local inferred token counts separately from provider-reported usage.
Caveman Engine use cases
Start with a repeated tool result that already has an expected outcome. Compare what the compressed view retains, how omitted detail is recovered and whether the agent’s decision still holds.
Triage recurring test failures
Use a representative test report with both passing cases and multiple failures. Check that failure details stay available in the compact view, then recover the full report when validating a borderline diagnosis.
Review a large diff without losing the patch
Test whether a compact diff helps the agent locate the right files and changes. Keep the original patch retrievable and use it for any line-level review before approving a merge.
Keep long log evidence traceable
Run a sanitized incident log through the same query with and without compression. Verify that the abbreviated result preserves the error sequence needed for triage and that omitted lines can be recovered before escalation.
Measure an agent’s context overhead
Compare local token estimates for a fixed set of tool outputs and log how many decisions require recovery. If you also have provider usage, reconcile it separately and retain the task-quality and latency results.
What to prepare for a compression trial
Start with representative inputs and an approved place to retain originals. Confirm the runtime and agent profile before sending live tool results through a compressed path.
A supported build and agent path
Choose the documented native CLI, Go library or another supported runtime. Agent-specific interception and recovery depend on the host protocol.
A controlled recovery store
Set a retention policy, capacity and access scope appropriate to the original inputs. Lossy output depends on a successful recovery path.
A comparison fixture
Keep a raw baseline, a known task outcome and exact details the compact representation must let you recover.
Related Software Projects
Compare the workflows, operating requirements, and source licenses of these projects.
Caveman Engine FAQ
Does the Caveman Skill enable the engine?
The Skill changes response style. The engine is separate runtime software for compressing what the model reads.
Can the engine recover the exact original?
Lossy output requires a recoverable original. Use the returned handle through the supported retrieval path to verify the original bytes.
What happens when no transform is suitable?
The documented flow passes through the source on parse failure, a larger result or an unavailable required recovery store.
Do inferred tokens measure my provider bill?
Local counters estimate tokens for comparison. Provider-reported usage and actual bills depend on the model, tokenizer and service.
Do all builds compress the same programming languages?
Support depends on the build. Upstream documents broader source-language parsing in the cgo release binaries than in the pure-Go builds.
Which versions use Apache-2.0?
Upstream applies Apache-2.0 from 3.0.0 onward. Earlier releases retain their shipped terms, and the separately hosted Caveman Cloud has its own commercial terms.