Memory Sidecar has long been the backbone for stateful agent operations, offering a dedicated memory layer that cleanly separates memory management from agent logic. With v3.5.1, the focus shifts firmly to operational hardening—this isn’t a feature dump, but a systematic tightening of reliability, security, and performance in production-grade deployments. The hermes-memory-installer further simplifies the path from testing to live environments, making this release a pragmatic upgrade for anyone running agent-agnostic memory services.
The core value of Memory Sidecar remains its agent-agnostic design: it doesn’t care if you’re using LangChain, AutoGPT, a custom framework, or even multiple agents simultaneously. v3.5.1 refines this foundation by addressing real-world pain points: transient failures, resource contention, and opaque error states. If you’ve been running earlier versions, the improvements in fault handling and instrumentation are immediately noticeable.
What’s New in v3.5.1
This release is built around three hardening pillars:
1. Fault Tolerance and Graceful Recovery
The sidecar now employs a write-ahead log (WAL) for pending state mutations, ensuring that crashes during write operations don’t corrupt core memory segments. On restart, it replays the WAL to restore consistency without manual intervention. Transient connection drops to the backing store no longer trigger cascading failures; the sidecar retries with exponential backoff, and if the store remains unreachable, it fails open with a cached snapshot rather than serving stale data or errors.
2. Resource Management and Backpressure
Memory and CPU limits are now enforced at the process level via cgroups. You can cap resident memory usage directly in the configuration, and when limits are approached, the sidecar applies adaptive backpressure—throttling incoming agent requests before resource exhaustion occurs. This is critical when multiple agents share the same sidecar instance. Additionally, a new leak detection metric (memory_sidecar_heap_growth) warns you if unmanaged references accumulate over time.
3. Observability and Security
Integrated Prometheus metrics are now enabled by default (exposed on a separate endpoint to avoid conflict). You get request latency histograms, error rates by type (write failure, timeout, authentication), and WAL status. Security hardening includes automatic secret rotation for session keys and a mandate for TLS 1.3 on communication channels. Default configuration files no longer ship with placeholder credentials—they must be explicitly set, reducing accidental exposure.
Code Example: Installing and Running v3.5.1
The hermes-memory-installer script is the recommended way to deploy. Here’s a quick setup that also applies a production-ready configuration:
# Install Memory Sidecar v3.5.1 with the installer
curl -sSL https://install.hermes-memory.dev | bash -s -- --version 3.5.1
# Create a hardened config
cat > /etc/memory-sidecar.yaml <<EOF
storage:
backend: rocksdb
path: /var/lib/memory-sidecar
limits:
max_memory_mb: 512
max_concurrent_agents: 50
security:
tls: true
tls_cert: /etc/certs/sidecar.crt
tls_key: /etc/certs/sidecar.key
metrics:
enabled: true
endpoint: "0.0.0.0:9091"
EOF
# Start the sidecar
memory-sidecar --config /etc/memory-sidecar.yaml
The installer grabs the binary and sets up a systemd service if detected. After that, it’s a matter of dropping in your config and starting the process.
Deep Dive: Operational Changes That Matter
Graceful Shutdown
Earlier versions had a bad habit of dropping in-flight writes when the process received SIGTERM. v3.5.1 intercepts termination signals, flushes the WAL, and waits for pending requests to complete (with a configurable timeout, default 30 seconds). If the timeout expires, it hard-exits, but the WAL ensures no data loss. This is essential in containerized environments where orchestration platforms (Kubernetes, Nomad) send SIGTERM during scaling events.
Backend Selection and Tuning
While RocksDB remains the default for its low latency and compaction reliability, v3.5.1 adds support for practical tuning profiles. You can choose a “memory-only” backend for ephemeral agent workspaces (cleared on restart) or a “persistent” mode with crash-recovery guarantees. The installer now includes backend-specific validation during setup—no more silent misconfigurations.
Agent-Agnostic Consistency
Because it’s agent-agnostic, Memory Sidecar doesn’t enforce schema conformity. v3.5.1 introduces optional vector versioning for timeline consistency (useful when multiple agents write to the same memory segment). This is exposed via the API but not required; if you don’t need it, the behavior is identical to previous versions. The difference is that when you do need it, the sidecar handles conflict resolution deterministically rather than relying on last-write-wins.
Why Upgrade Now?
If you’re running any version below 3.5.0, the operational hardening alone justifies the upgrade. The fault-tolerant WAL and adaptive backpressure reduce the need for manual restarts and monitoring thresholds. The hermes-memory-installer cuts deployment time from minutes to seconds, with a single command fetching the validated binary and default profile.
For teams managing multiple agent frameworks, the agent-agnostic design combined with hardened resource controls means you can consolidate memory services behind one sidecar instance. The new metrics endpoints let you set up alerts before problems escalate—for example, a spike in memory_sidecar_write_retries indicates a struggling storage backend, not a sidecar bug.
Memory Sidecar v3.5.1 doesn’t add flashy new agent features. It makes what you already have more reliable, more observable, and less likely to burn you during a production incident. That’s the kind of release that earns a quiet upgrade and a note in the release notes: “This is the version we should have shipped first.” If you’re currently relying on ad-hoc memory management, the sidecar path is now production-tested and ready for your worst-case load.
SOCIAL SHARE CARD GENERATOR