FIRST TRIP / FOUR-FILE MIX
98.50%INSTALLATION GUIDE / VERSION 3.0
Install AhanaWire 3.0.6.
The first trip is 98.50% smaller.
31,334 bytes leave as 469 on the very first send, before any cache exists. Repeats shrink to a 150-byte reference. The receiving edge brings back the full original, byte for byte.
Your infrastructure. Your cache. Your existing link.
Our goal: speed up the internet one device at a time, so existing networks carry more and fewer massive data centers are needed.
TO SCALE · FOUR-FILE MIX
Bars are linear. First trip needs no cache; the next trip needs the chunks already at the receiving site. Sources & scope ↓
NEXT TRIP / WARM CACHE
99.52%SPEED / LOCAL HTTP PAIR
1.40 msRepetitive operational text, not every file. Sizes: measured frames. Speed: Nov 19, 2026 local reference run, not internet latency. How we measured ↓
DOWNLOAD
AhanaWire 3.0.6
- Version
- 3.0.6
- Platform
- Linux x86-64 (Docker Engine with compose)
- File
ahanawire-3.0.6-linux-amd64.tar.gz- Size
- 123,932 bytes (121 KB)
- SHA-256
ca1177e8f4a3c9e7775c9b2d5054633926b61d3b9aeb42e116166e185d1e78a0- Signature
- .minisig · .sha256 · public key · SHA256SUMS
One-line install
Put your key in $HOME/.ahanawire-key (mode 600) first, then run:
V=3.0.6; T=ahanawire-$V-linux-amd64.tar.gz; curl -fsSLO https://ahanaai.com/ahanawire/releases/$V/$T && curl -fsSLO https://ahanaai.com/ahanawire/releases/$V/$T.sha256 && sha256sum -c $T.sha256 && tar -xzf $T && ./ahanawire-$V-linux-amd64/install.shThis checks the SHA-256. The signature check with minisign is in step 03 below.
A key is needed to activate. The edges do not start without one. Get it with a plan: Start or see pricing, including the Free plan and the 14-day Pro trial.
FIRST TRIP · HEAD TO HEAD
31,334 → 469 bytes
98.50% fewer bytes on the very first send. Same 31,334-byte mix, each tool measured on the same bytes.
Smaller is better. Bars to scale against lz4-1. Same four-file mix, re-measured on AhanaWire 3.0.0, Nov 19, 2026; first trip on the default setting and on the measured test link, no cache (link speed in Measurement notes). zstd-3, gzip-6, and lz4-1 are CLI measurements on the same bytes (zstd 1.5.7, gzip 1.14, lz4 1.10.0). Ratios = 31,334 ÷ frame bytes (AhanaWire 66.8102:1, zstd-3 38.4939:1, gzip-6 32.6396:1, lz4-1 28.7996:1). Results on other data will differ.
THE FIRST TRIP, FILE BY FILE
First-trip frames, before any cache exists.
Published first-trip frames.
Bars are to scale within each row.
WHAT GETS STORED IS TINY
Small chunks on your disk. A 17-byte reference on the wire.
AhanaWire cuts each message into content-defined chunks between 1,024 and 16,384 bytes (a message shorter than 1,024 bytes is one chunk). Each chunk is kept once, under its 64-bit fingerprint, on a disk you run. Repeats are not stored again.
On AhanaAI's own running pair the stored chunks are measured at:
- Median chunk
- 422 B
- Average chunk
- 455 B
- Chunks stored
- 37,564
- Whole cache
- 17.1 MB
Compress-side cache, read Nov 19, 2026, 10:33 AM HST. The receiving side held 38,391 chunks (median 422 B, average 601 B, 23.1 MB). Chunks are plain pieces of your data, so the receiving site can rebuild without asking anyone. That pair has moved 273.4 MB since its last restart.
One median stored chunk · 422 B
What crosses the link for it · 17 B
Each dot is one byte. Reference = 1 byte kind + 8 byte fingerprint + 4 byte length + 4 byte payload size. A frame adds a 12-byte header, so the 150-byte next trip of the mix is 4 headers + 6 chunk references.
A SHORT WALKTHROUGH
Install. Activate. Send less.
Install, send, then bring the original back.
Illustrated sequence—not a live installation.
01 / INSTALL
A pair on each machine.
Start compress and expand together. Each site keeps its own persistent disk cache.
$ docker compose up -d --buildRun after receiving the edge binary.
Your key comes from your account; the signed Linux binary is public.
The egress meter illustrates the measured four-file mix, not a single frame. The speed counter reveals a separate measured reference; it is not timing this animation. Controls pause or replay the sequence. Reduced-motion settings are respected.
THE SIGNED 3.0.6 PATH
Your first installation.
One site = one compress edge, one expand edge,
and one customer-owned cache.
Before you start
A Linux x86-64 host, Docker Engine with the Compose plugin, curl, sha256sum, tar, bash, and a persistent writable disk. Signature checks use minisign, or Docker to run the pinned minisign image.
Have your key ready
The edges refuse to start without an API key. The 3.0.6 release is public and signed; the key comes with your plan. After checkout, sign in at ahanaai.com/account/ and create it on the Keys page. Enterprise pilots are arranged with AhanaAI.
Download AhanaWire 3.0.6 (Linux x86-64, 123,932 bytes)
SHA-256 ca1177e8f4a3c9e7775c9b2d5054633926b61d3b9aeb42e116166e185d1e78a0 · .sha256 · .minisig · public key
- 01
Put your API key in a private file.
After checkout, set your password from the emailed link, sign in at ahanaai.com/account/, and create a key on the Keys page. It is shown once. Enterprise pilots get their key from AhanaAI. Write it to a file that only you can read. Never paste the key into a chat, a ticket, a command line, or a shell history.
The license URL is an API directory, not an installation form. Start with a plan, or apply to be an enterprise pilot partner. An AI agent does not write the key: the user puts it in the file, outside the chat. If the key is already in the environment as
AHANAWIRE_API_KEY, skip the file.touch "$HOME/.ahanawire-key" && chmod 600 "$HOME/.ahanawire-key"Open
$HOME/.ahanawire-keyin a text editor, paste the key as the only line, and save. The file must stay mode 600. SetAHANAWIRE_API_KEY_FILEif you keep it somewhere else.install.shreads the file and never prints the key. - 02
Download the signed 3.0.6 release.
The bundle holds the
ahanawireedge binary,install.sh, the Dockerfile, the Compose and Kubernetes templates, the public key, and a checksum list. Download the archive, its SHA-256 file, and its minisign signature.V=3.0.6 T=ahanawire-$V-linux-amd64.tar.gz R="${AHANAWIRE_RELEASES:-https://ahanaai.com/ahanawire/releases}/$V" mkdir -p "$HOME/ahanawire-download" && cd "$HOME/ahanawire-download" curl -fsSLO "$R/$T" && curl -fsSLO "$R/$T.sha256" && curl -fsSLO "$R/$T.minisig" - 03
Verify the checksum and the signature.
Check the SHA-256, then verify the minisign signature with the published public key. Do not run anything from the download until both checks succeed.
sha256sum -c "$T.sha256" PUB=RWQTvTlH/J3qidyLu6hOdfA7S902A2lLg6cIsI4Xm660P3gEqchzyVPb if command -v minisign >/dev/null 2>&1; then minisign -Vm "$T" -P "$PUB"; else docker run --rm -v "$PWD:/w:ro" -w /w jedisct1/minisign@sha256:ee60186c5d05e342e66cbc81133aa744d026752d909d8ea021a15c4d16b1193b -Vm "$T" -P "$PUB"; fiThe checksum line must say
OK, and minisign must report a valid signature. The same public key is at ahanawire-release.pub. If either check fails, stop and download again. - 04
Install with install.sh.
Unpack the verified archive and run
install.sh. It reads the key from$HOME/.ahanawire-keyor fromAHANAWIRE_API_KEY, starts the compress and expand edges, and leaves state under$HOME/ahanawire(orAHANAWIRE_HOME).tar -xzf "$T" "./ahanawire-$V-linux-amd64/install.sh"Exit code 0 means the install completed and the pair is healthy. Exit code 2 means it was already installed and healthy, or already on that version; nothing changed. Exit code 1 failed; the FIX line (or the
fixfield with--json) says what to do.The template binds ports 19752 and 19754 to
127.0.0.1only. Override withAHANAWIRE_COMPRESS_PORTandAHANAWIRE_EXPAND_PORTif those ports are taken. To reach a remote site, keep those bindings and put an authenticated TLS reverse proxy (or a private encrypted tunnel) in front, with a firewall allowlist. Never publish plaintext edge ports to the internet. On Kubernetes the services stay internal (ClusterIP). - 05
Check it works. Then connect the receiving site.
install.sh --checkconfirms both edges, release 3.0.6, and a lossless keyed round trip, without printing the key."${AHANAWIRE_HOME:-$HOME/ahanawire}/current/install.sh" --checkWith
--jsonit printsok true, every check true, andreported_version 3.0.6. Later,--updateinstalls the latest signed release (the cache is kept),--rollbackreturns to the previous release, and--uninstallremoves the install (the cache and key are kept unless you pass--remove-cacheor--delete-key).Repeat the setup at the receiving site. Wire your application to
POST /wire/compresslocally, transport the returned frame over your existing link, thenPOST /wire/expandat the destination. There is no automatic network-wide interception.Keep the persistent chunks available at both ends. Confirm the destination can expand a first copy before testing next-copy references. Compare original bytes, transmitted frames and end-to-end time on representative traffic.
Do not skip the cross-site cache check. Two sites do not share a disk. Confirm peer-cache configuration and cache-miss recovery with AhanaAI before production.
Deploying on Kubernetes instead?
The k8s.yaml in the verified 3.0.6 package creates one namespace, a key Secret, one compress pod and one expand pod (both run as user 65532 with fsGroup 65532 so the cache is writable, with health probes and resource limits), internal ClusterIP services, and a shared 10 GiB persistent-volume claim. This is a template allocation, not a proven minimum requirement.
Build the image from the package folder and push it to a registry your cluster can pull from (k3s and containerd cannot see a local Docker image), set that image in the manifest, place the key in the Secret privately, then apply:
docker build -t YOUR_REGISTRY/ahanawire:3.0.6 .
docker push YOUR_REGISTRY/ahanawire:3.0.6
kubectl apply -f k8s.yamlBoth pods share one ReadWriteOnce claim, so run them on one node or use a ReadWriteMany storage class; do not increase replicas without checking storage access and scheduling. Use a different namespace, key, and cache for each customer.
LOSSLESS RESTORE
Back to full size, byte for byte.
One API call on the receiving edge.
Your application or a single command makes it.
469 B first trip, or a 150 B reference on repeats.
The receiving edge on port 19754 reads each entry.
Each reference is looked up by fingerprint; length and fingerprint are re-checked.
Exact bytes back. A frame that fails any check is refused (HTTP 400).
curl --fail --silent --show-error \
-H "X-API-Key: $AHANAWIRE_API_KEY" \
--data-binary @frame.ahw2 \
http://127.0.0.1:19754/wire/expand -o restored.bin
sha256sum original.bin restored.bin # the two hashes matchProof in the reference run: 12,187 of 12,187 round trips restored with zero identity failures, and all 16 deliberately damaged frames were refused. The same restore is one click in the command center.
COMMAND CENTER · CACHE AND AW ENDPOINTS IN 3.0.6
Your install, on one local page.
install.sh starts it on your own machine at http://127.0.0.1:19770/.
It shows only this install and never asks for your key.
- 01
Open it on the machine you installed on.
From 3.0.5, when you run
install.shin a terminal on a desktop, it opens the page in your browser when the install finishes. It does not open it when run as root, over SSH, in CI or with--json, andinstall.sh --no-openskips it. The address is always printed. Otherwise, go tohttp://127.0.0.1:19770/in a browser on that machine. It answers only on 127.0.0.1 and localhost. From another computer, use an SSH tunnel:ssh -L 19770:127.0.0.1:19770 you@your-host, then open the same address there. - 02
Create the first admin with the one-time setup code.
install.shwrites the code to a private file. Read it, paste it into the page with your email and a passphrase of 12 characters or more. The code works once and is then deleted. Admins can add viewers, who can see everything but change nothing.cat ~/ahanawire/center/setup-code - 03
Manage the install from the page.
Check for and install signed updates, roll back to the previous release (the cache is kept), install an offline signed bundle, verify a lossless round trip, restore a compressed copy with one click (the receiving edge expands it, the SHA-256 fingerprint is checked, and you download the file), see this install's own usage, and uninstall. Keys, plan and billing stay in your account.
- 04
Choose where the cache lives, and its cap.
The Install tab has an AW Endpoints and their cache section. For each AW Endpoint it shows where the cache lives, its drive, the cap, how much is used and the free space on the drive. Admins can move a cache to another drive (a new or empty folder; the free space is checked first) and pick its cap: 10 GiB by default, up to 2 TiB or no cap. Only that AW Endpoint restarts, for a few seconds; the command center and your sign-in keep running. Cache folders are private to the edge (0700 folders, 0600 files). At the cap, the oldest data is removed first. Each AW Endpoint leaves the smaller of 5% of the drive and 1 GiB free, and if the drive gets full anyway, new data is simply not cached: requests keep working.
~/ahanawire/current/install.sh --show-config ~/ahanawire/current/install.sh --set-cache --cache-dir-expand /mnt/big/ahanawire-cache --cache-max-expand 500GAt install time,
install.sh --cache-dir DIR --cache-max 50Gsets both (or--cache-dir-compress,--cache-dir-expand,--cache-max-compress,--cache-max-expandfor one each). - 05
Stop or start one AW Endpoint.
Admins can stop the sending (compress) or receiving (expand) AW Endpoint on its own; the page asks you to confirm before it stops, and each start and stop is written to the audit log. From a terminal:
install.sh --endpoint-stop expandandinstall.sh --endpoint-start expand. An update, rollback or repair starts both again.
Other ports, opting out, and Kubernetes
Set AHANAWIRE_CENTER_PORT before install.sh to use another local port. Run install.sh --no-center to leave it out, and install.sh --with-center to add it back; your accounts are kept. To stop everything by hand: docker compose -p ahanawire --profile center down (the cache is kept). On Kubernetes, k8s.yaml adds an ahanawire-center Service: set AHANAWIRE_CENTER_SETUP_CODE in the key Secret, then kubectl -n ahanawire port-forward svc/ahanawire-center 19770:19770. Install changes on Kubernetes are made with kubectl, and the page shows how. In 3.0.6 the cache claim is 22Gi (both 10 GiB caps plus 10%); size it to your caps (AHANAWIRE_CACHE_MAX_BYTES) and choose its disk with storageClassName.
WHAT YOU GET
Less egress. A verified original.
Speed you can measure.
Lower payload egress
Egress is data leaving your network. Sending fewer bytes can reduce usage-based bandwidth charges. On the reference mix, the next copy is 150 bytes instead of 31,334.
A fast local pair
The Nov 19 reference run completed 12,187 of 12,187 jobs, with 0.9546 ms p50 and 1.3953 ms p99 compress-plus-expand time over local HTTP.
AMD Ryzen 9 9900X
This is service latency, not WAN delivery time. Fast links and incompressible data can be slower after processing overhead.
Your data stays yours
Your original is restored at the far edge. Chunks remain on infrastructure you run. The reference run reported no identity failures, and all 16 damaged test frames were rejected.
AhanaAI issues a key; the data path is between your machines. Preserve and isolate caches, and validate lossless restoration before connecting production workloads.
THE FOUR-FILE MIX
What actually crossed the link.
Chat, handoffs, logs and mixed operational text. Exact totals from the reference mix.
Next-copy state assumes the receiving cache is warm. Results do not generalize to encrypted, random, or already compressed data.
On a link one hundred times faster than the measured test link, the first trip of this mix is 31,406 bytes: the original plus an 18-byte frame header per file. The next trip is still 150 bytes. Restore was identical on every file in this run. 16 of 16 damaged frames were refused. Link speeds are in Measurement notes.
MORE MEASURED NUMBERS
Egress and speed beyond the reference mix.
Each figure has its own source and scope. They come from different runs and should not be added together.
273,367,257 bytes in → 8,702,365 bytes on the wire (31.4:1) across 121,002 requests, with no identity failures.
AhanaAI's own running 2 AW Endpoints (1 pair): cumulative counters read from its health endpoints on Nov 19, 2026 at 9:20 AM HST. That pair carries AhanaAI's internal traffic, not customer data.
Effective speedup on one measured slow path: mixed data arrived 90.6× sooner and logs 45.9× sooner than sending them raw. Path speed is in Measurement notes.
With/without test from a remote test machine, Nov 19, 2026 at 9:12 AM HST. Each payload is a single message on that one slow path.
208.9× more original data per byte sent on the next copy of the four-file mix (150 bytes for 31,334).
Published product page, measured mix. “Effective” means more original data per byte sent; the link itself does not get faster.
Original mixed text through one pair moved far more data than the wire carried. Throughput figures are in Measurement notes.
Published product page: 16 clients, about 8 seconds, warm next frame, every job restored.
Effective speedup on log clocks: logs finished 47.7× sooner on a full test link and 6.7× sooner on a link ten times faster. Link speeds are in Measurement notes.
Published product page: October 2026 in-process version 1 clocks (47.7366× and 6.6793×), no added round-trip delay, logs only.
Will my connection get faster?
The link itself does not change speed. Smaller frames reduce serialization time, while compression, expansion and network round trips add time. The Nov 19 scorecard models the mixed payload at 0.5339 ms vs 12.5344 ms raw on the slower test link with zero added RTT. That is a model using measured service clocks, not a field speedup. On a link one hundred times faster the same model is slower with AhanaWire (0.4975 ms vs 0.1253 ms raw). The slow-link and log-clock wins above apply to constrained links; on fast links, expect the time saving to disappear. Link speeds are in Measurement notes. Measure the actual path before making a speed claim.
FOOTNOTES · MEASUREMENT NOTES
Real figures. Clear boundaries.
Egress
AhanaWire 3.0.0, re-measured Nov 19, 2026, about 11:50 AM HST, on the same 31,334-byte mix: on the default setting and on a 10 Mbps link the first trip is 469 bytes and the next trip is 150 bytes. AhanaWire 3.0.3 gives the same sizes on this mix (469 bytes first trip, 150 bytes next trip, every file restored identically), checked in the 3.0.3 release build on Nov 20, 2026. At 1,000 Mbps the first trip is 31,406 bytes (original plus 18 bytes per file) and the next trip is still 150 bytes. Savings are calculated as 1 − wire / original: 98.50% first, 99.52% next. The animated values are illustrative transitions between those measured endpoints.
Cost
Decimal 1 TB = 1,000 GB, at an illustrative $0.09/GB. Raw payload: $90. Next-copy payload: $90 × 150 / 31,334 = $0.43, rounded. Real bills include more than the payload.
Speed & integrity
Slow-link test: the remote path measured about 0.05 Mbps, Nov 19, 2026 at 9:12 AM HST; each payload was a single message on that one path. Log-clock links: 10 Mbps and 100 Mbps. Scorecard model links: 10 Mbps and 1,000 Mbps. Throughput on the published product-page pair: mixed original text 271.247 MB/s while the wire carried 0.796 MB/s; p99 1.548 ms.
Local quick scorecard captured Nov 19, 2026 at 3:20 AM HST. Four clients over loopback HTTP, 5-second run; 12,187 jobs; 2,436.64 jobs/s; p50 0.9546 ms; p99 1.3953 ms. No job identity failures. All 16 corrupt test frames rejected. CPU: AMD Ryzen 9 9900X; Linux. Not a sustained capacity test.
Installation scope
Commands follow the signed 3.0.6 release and install.sh. The public bundle, checksums and minisign signatures are in the download card at the top of this page. install.sh --check confirms both edges, release 3.0.6, and a lossless keyed round trip. The first-trip and next-trip sizes, and the CLI baselines, were re-measured on 3.0.0 on Nov 19, 2026, about 11:50 AM HST, on the same four-file mix.
START WITH YOUR OWN TRAFFIC
Make the next trip smaller.
Pick a plan, create your key, get the signed edge binary. Test the pair. Measure the result.