About the Akave Protocol
The Akave protocol is the decentralized data layer underneath O3, responsible for chunk placement, replication, PDP-backed durability, indexing, and retrieval across nodes.
December work reinforced the same three fundamentals as always:
Security – Performance – Operability
This month leaned heavily into operability: making sure nodes don’t stall, SDKs don’t overload networks, and PDP aggregation behaves correctly even in edge cases.
Protocol Stability & Correctness
PDP loop hardening (v0.4.5)
We fixed a subtle but serious PDP aggregation issue:
- Duplicate piece handling could previously cause the PDP loop to stagnate when attempting to add an already-existing piece to a dataset.
- The loop would not advance, effectively halting aggregation despite valid data.
Fix:
The PDP loop now safely detects and skips duplicate pieces, ensuring aggregation always progresses.
This is the expected baseline for anyone running PDP-backed storage in production.
Streaming cleanup & indexer safety (v0.4.2)
December fully closed the door on deprecated streaming paths:
- Removed remaining streaming leftovers across node, IPC, P2P, and test networks.
- Simplified protocol state by removing unused streaming-related data models and configuration.
Indexer robustness improvements:
- Invalid transactions are now skipped during block parsing instead of halting indexing.
- Prevents the indexer from repeatedly retrying the same bad block and stalling the chain-follow loop.
- Block log fetch batch size is now configurable, avoiding out-of-memory and revert scenarios during high chain load.
Net result: indexers advance deterministically, even under malformed or overloaded block conditions.
Performance & Throughput
SDK connection pooling (v0.4.4)
The SDK now uses a shared connection pool per instance:
- Prevents uncontrolled connection growth during concurrent uploads/downloads.
- Reduces connection churn and improves performance consistency under parallel workloads.
- Especially important for agents, batch jobs, and multi-threaded ingestion pipelines.
This brings SDK behavior closer to how production clients actually operate.
Smarter chunk peer selection (v0.4.4)
Chunk upload fallback logic was improved:
- When a pinged node fails for a block, peers are now selected from a random permutation of the node set.
- Prevents silent fallback to the same small subset of nodes.
- Improves distribution and reduces correlated failure patterns.
This directly strengthens durability and load spreading across the network.
Memory allocation optimizations (v0.4.3)
Node-side upload paths now:
- Preallocate a 1 MiB buffer for block uploads.
- Reduce repeated allocations and GC pressure during sustained write workloads.
This shows up as smoother memory profiles and more predictable latency under load.
Transaction Loop & Contract Safety
Transaction retry correctness (v0.4.3)
Fixed a bug where failed batch chunk upload transactions could retry infinitely:
- Successful retries now correctly remove the transaction from the retry queue.
- Prevents runaway loops and unbounded retry behavior.
This is critical for long-running nodes operating under intermittent chain conditions.
Storage contract authority & pagination fixes (v0.4.3)
Contract-level improvements included:
- Introducing explicit upgrade authority for the Storage contract, preventing unauthorized upgrades.
- Fixing pagination logic where listing buckets could previously copy excessive state into memory, causing execution reverts for large buckets.
Important note:
The v0.4.3 contract introduces a backwards-incompatible state change. Existing contracts cannot be upgraded in place and require redeployment. Nodes and SDKs remain compatible, but contracts must start clean.
API & Operational Guardrails
Internal API isolation (v0.4.2)
All internal APIs were moved behind a dedicated internal gRPC server:
- Internal endpoints are no longer exposed unless explicitly configured.
- Reduces accidental surface exposure and tightens operator control.
Error quality & diagnostics (v0.4.3)
Node API and IPC errors were upgraded to:
- Use structured gRPC error codes.
- Provide clearer, more actionable error messages.
- Avoid generic error mappers that obscure root causes.
This improves both operator debugging and SDK error handling.
Version visibility (v0.4.5)
The version command now reports:
- Git tag information.
- Dirty working tree status.
- Non-tagged commit context.
Operators can now reliably identify exactly what is running in production; no guesswork.
Release Recap (December)
Akave v0.4.2
Protocol cleanup and indexer resilience
- Streaming fully removed
- Indexer skips invalid txs
- Configurable block log batch sizes
- Internal gRPC server isolation
Akave v0.4.3
Correctness, memory, and contract safety
- Transaction retry loop fixes
- Storage contract authority
- Pagination OOM fix
- Improved error semantics
- Memory preallocation for uploads
Akave v0.4.4
Throughput and distribution
- Shared SDK connection pooling
- Smarter peer selection for chunk uploads
Akave v0.4.5
PDP stability and operability
- Fixed PDP loop stagnation on duplicate pieces
- Improved version command diagnostics
What’s Next
Operational confidence
- Continued PDP observability and aggregation metrics.
- Clearer signals tying PDP state back to object health.
Protocol-to-product linkage
- Surfacing protocol health (datasets, pieces, aggregation state) into higher layers.
- Making durability and verification visible, not implicit.
Scaling safely
- More stress testing around large datasets, long-running nodes, and agent-driven workloads.
- Ensuring the protocol remains predictable as usage patterns evolve.
December didn’t add flash, it added “trust”.
And that’s exactly what the protocol layer needs.
If you want to run Akave at scale, this is the foundation it stands on.
FAQs
What is the Akave protocol?
The Akave protocol is the decentralized data layer underneath Akave O3, responsible for chunk placement, replication, PDP-backed durability, indexing, and retrieval across nodes. It's the foundation that makes Akave's storage verifiable, resilient, and performant at scale.
What is PDP and why does it matter?
PDP (Proof of Data Possession) is the cryptographic mechanism that verifies your data is actually stored where it's supposed to be. The December updates hardened the PDP aggregation loop to handle edge cases like duplicate pieces, ensuring durability verification always progresses—critical for anyone running production storage workloads.
What changed in the SDK for December?
The SDK now uses shared connection pooling per instance, preventing uncontrolled connection growth during concurrent uploads and downloads. This reduces connection churn and improves performance consistency for agents, batch jobs, and multi-threaded ingestion pipelines.
Why were streaming paths removed?
December fully removed deprecated streaming code across node, IPC, P2P, and test networks. This simplifies protocol state, reduces maintenance overhead, and eliminates unused code paths that could introduce bugs or security surface area.
What does "indexer resilience" mean in practice?
The indexer now skips invalid transactions during block parsing instead of halting entirely. This prevents the indexer from stalling on malformed blocks and ensures chain-following continues deterministically—even under overloaded or degraded chain conditions.
Is the v0.4.3 contract upgrade backwards-compatible?
No. The v0.4.3 contract introduces a backwards-incompatible state change. Existing contracts cannot be upgraded in place and require redeployment. Nodes and SDKs remain compatible, but contracts must start clean. This was necessary to fix pagination issues and introduce explicit upgrade authority.
What's coming next for the protocol?
January focuses on three areas: continued PDP observability and aggregation metrics, surfacing protocol health (datasets, pieces, aggregation state) into higher layers, and stress testing around large datasets, long-running nodes, and agent-driven workloads to ensure predictability as usage scales.
Akave Cloud is an enterprise-grade, distributed and scalable object storage designed for large-scale datasets in AI, analytics, and enterprise pipelines. It offers S3 object compatibility, cryptographic verifiability, immutable audit trails, and SDKs for agentic agents; all with zero egress fees and no vendor lock-in saving up to 80% on storage costs vs. hyperscalers.
Akave Cloud works with a wide ecosystem of partners operating hundreds of petabytes of capacity, enabling deployments across multiple countries and powering sovereign data infrastructure. The stack is also pre-qualified with key enterprise apps such as Snowflake and others.