Akamas - Autonomous AI for Kubernetes Cost and Performance

TL;DR

TL;DR: Akamas is an autonomous optimization platform that uses patented reinforcement learning to continuously tune Kubernetes workloads, JVM/Node.js runtimes, HPA baselines, and cloud instance sizing at the full stack, with recommendations applied safely from your existing observability data.

Source and Accuracy Notes

• Product site: akamas.io
• Platform overview: akamas.io/insights/ and akamas.io/platform/
• HN launch thread: Show HN: Akamas Insights now GA (December 2025, 16 points)
• KubeCon EMEA 2026 announcement: HPA-aware optimization and Node.js runtime tuning
• Recognized as a Leader and Outperformer in the 2026 GigaOm Radar for Cloud Resource Optimization

What Is Akamas?

Akamas is a Milan-based startup (one of Italy’s 2026 soonicorns) that builds an AI-powered optimization platform for Kubernetes and cloud-native applications. The product’s premise is that modern cloud applications are too complex for humans to tune by hand: a single Java service running on Kubernetes can have hundreds of interacting configuration knobs across the JVM, the container, the pod, the HPA, and the underlying node type. Akamas takes a reinforcement-learning approach, learning from your existing observability metrics, exploring the configuration space autonomously, and surfacing or applying the changes that improve cost, latency, or reliability.

The platform has two products:

• Akamas Insights (GA December 2025) — a SaaS control plane that connects to your observability stack (Prometheus, Datadog, Dynatrace) and continuously analyzes telemetry to find cost, reliability, and best-practice issues across Kubernetes clusters. It scores each finding by impact and lets you apply the change with one click or automatically.
• Akamas (full platform) — the optimization engine itself, which not only finds opportunities but also runs closed-loop experiments in production or in test environments to identify optimal full-stack configurations using reinforcement learning.

Why Kubernetes Optimization Needs AI

The default Kubernetes setup is wasteful by design. Most teams ship with a Helm chart that requests the same CPU and memory for every pod, regardless of actual workload behavior. JVM and Node.js runtimes ship with conservative defaults that are far from optimal for the workload. HPA thresholds are set to whatever the chart author thought was safe. Result: most organizations over-provision by 30–60% on cloud cost, and still hit throttling and Out-Of-Memory issues.

The traditional fix is a performance engineering team manually running load tests, reading flame graphs, and tweaking configurations. This works but is slow, episodic, and breaks the moment a workload changes. Akamas’s bet is that this tuning loop should be continuous and automated, the same way a self-driving car continuously adjusts steering and throttle based on sensor input.

The KubeCon EMEA 2026 announcement put it precisely: “Autoscaling determines when to scale. Akamas determines what each pod should look like before scaling begins.” That distinction is the entire product: HPA and KEDA still operate, but they scale from a baseline that has been right-sized by the optimizer.

What Akamas Actually Optimizes

The platform’s full-stack scope is what separates it from typical rightsizing tools. It optimizes the configuration dependencies across every layer:

• Kubernetes workloads — pod CPU and memory requests/limits, HPA min/max replicas, threshold settings, and detection of scaling inefficiencies like throttled scale-ups or insufficient replica caps
• JVM on Kubernetes — heap sizes, GC algorithm choice, GC tuning flags, JIT compiler settings. Java on K8s is responsible for over 50% of cloud costs at 62% of organizations, and default JVM configs leave a lot on the table
• Node.js runtimes — V8 heap, garbage collection, libuv thread pool size, and other Node-specific knobs that affect memory and event loop behavior
• Cloud instance types — the right family and size for each workload, balancing performance, cost, and carbon footprint
• Big Data (Spark) — executor memory, shuffle partitions, and cluster sizing for Spark jobs
• AI/GPU workloads — introduced as a focus area in 2026, tuning the serving engine, GPU allocation, and infrastructure together to lower cost per token while keeping latency targets

All of this is done with full application awareness: the optimizer looks at how a configuration change at one layer affects the layers above and below, so a JVM heap increase doesn’t trigger an OOM kill at the pod level, and a pod scale-up doesn’t break the HPA’s target utilization.

How the Reinforcement Learning Loop Works

Akamas’s core technology is a proprietary reinforcement learning engine trained specifically on the configuration search problem. The loop looks like this:

1. Connect — Akamas reads telemetry from your existing observability stack (Prometheus, Datadog, Dynatrace) and discovers the workloads running in your clusters. No agents, no code changes.
2. Explore — In an offline (testing) environment, the engine generates candidate configurations and runs them through performance tests, observing how cost, latency, and resource usage respond. The reinforcement learner scores each experiment and uses the result to guide the next experiment.
3. Recommend — In production, Akamas runs the Insights product, which analyzes live telemetry to detect issues and estimate the impact of fixing them. Findings are scored and ranked: this pod has 5 reliability risks and a $4,901.46/month savings opportunity.
4. Apply — With your approval, Akamas applies the configuration change. The “Apply Now” workflow validates that the change does not conflict with HPA behavior, runtime constraints, or SLOs.
5. Monitor — The platform continues to observe the workload, and if a change degrades performance, it rolls back.

For teams that want full closed-loop optimization, the platform version runs the same loop end-to-end in production, with the AI continuously adjusting configuration as workload behavior changes.

Setup Workflow

Step 1: Create an Akamas Account

Sign up at akamas.io. The Insights product has a self-serve signup with a savings calculator that estimates your potential cloud-cost reduction from a sample of your cluster metrics.

Step 2: Connect Your Observability Stack

Akamas reads from Prometheus, Datadog, or Dynatrace. The connection is read-only and uses your existing scrape data, no agents required. Permissions are scoped to the namespaces and metrics you specify.

Step 3: Run the Initial Analysis

Once connected, the platform takes 10–30 minutes to ingest the metric history and run its first pass. You will see a dashboard with:

• An Overall Health Score (e.g. 80% Good) for reliability, broken down by clusters/nodes and workloads/runtimes
• An Expected Impact panel showing total monthly savings (e.g. $4,901.46/mo, -9%) and reliability risks that would be auto-resolved
• A list of Optimization Opportunities ranked by impact, each with an “Apply Now” button

Step 4: Apply a Recommendation

Pick a finding, review the before/after configuration, and click “Apply Now.” Akamas validates that the change does not conflict with HPA, runtime, or SLO constraints, then writes the new configuration to your cluster via GitOps or kubectl, depending on your setup.

Step 5: Enable Continuous Optimization (Optional)

For workloads where you have a representative test environment, enable the offline optimization engine. Akamas will explore configurations in test, find the optimal settings, and surface them as production recommendations on a continuous basis.

Deeper Analysis: HPA-Aware Optimization

The most interesting capability introduced in 2026 is HPA-aware optimization. HPA and KEDA are the standard way to scale Kubernetes workloads, but they have a structural weakness: they scale from whatever baseline you give them. If your CPU request is 10x what the workload actually needs, HPA will spin up 10x more pods than necessary at peak.

Akamas does not touch HPA’s scaling rules. It optimizes the baseline from which HPA scales. In practice this means:

• Generating right-sized CPU and memory requests so each replica uses the right amount of resources
• Aligning runtime configs (JVM heap, V8 heap) with scaling dynamics so cold-starts do not trigger scale-out
• Detecting scaling patterns that are themselves symptoms of bad config: throttled scale-ups, OOMs during traffic spikes, replicas hitting their max cap

The platform scores each HPA-managed service on “scaling efficiency” and ranks fixes by impact. In the Akamas-Insights-Cover-Image, you can see this in action: the “Container” card shows CPU Requests going from 300 to 200 milliCores, CPU Limits from 1,000 to 670, Memory Request from 3,000 to 2,500 MiB, and the JVM Heap Size from 1,500 to 1,250 MB, all from a single optimization pass.

Practical Evaluation Checklist

Before adopting any autonomous optimization tool, validate:

• Safety guarantees. Akamas validates that proposed changes do not conflict with HPA, runtime, or SLO constraints. Verify this is the case in your environment, and that the rollback mechanism is reliable.
• Read-only access. Akamas reads from your observability stack, not from your application. Confirm that the write path (GitOps or kubectl) requires your explicit approval and is auditable.
• Workload coverage. The platform supports JVM, Node.js, Spark, and AI/GPU workloads. Confirm your stack is covered; if you have niche runtimes (Erlang, Rust, Go), check whether the optimization engine has knowledge of their tuning parameters.
• Cold start cost. The initial analysis pass takes 10–30 minutes, but full optimization including the reinforcement learning loop runs over days. Budget for this when evaluating.
• Cost model. Akamas’s pricing is per workload, not per cluster, so the cost scales with the number of services you optimize, not the size of your infrastructure. Run the savings calculator before committing.

Security Notes

• All connections from Akamas to your observability stack are read-only and use scoped credentials.
• Configuration changes are written via your existing GitOps pipeline (ArgoCD, Flux) or via kubectl, with audit logging.
• The platform runs the optimization loop in a SaaS control plane (Insights) or a self-hosted engine (full platform) — choose the deployment model that matches your data residency requirements.
• For production rollouts, the “Apply Now” workflow requires explicit approval; there is no autonomous write path that bypasses human review unless you opt in.

FAQ

Q: How is Akamas different from a standard rightsizing tool like Karpenter or Spot.io? A: Rightsizing tools recommend a new instance type or pod size. Akamas tunes the full stack, including JVM, Node.js, HPA, and Spark, using reinforcement learning rather than static heuristics. It is closer to a performance engineer that never sleeps than a capacity planner.

Q: Does Akamas work with non-Kubernetes workloads? A: The Insights product focuses on Kubernetes. The full Akamas platform also supports Spark, traditional VMs, and AI/GPU serving, but the Kubernetes story is the most mature.

Q: Can I run Akamas fully on-prem? A: Yes. The full platform supports self-hosted deployment. Insights is SaaS-only.

Q: How long until I see savings? A: The initial Insights pass surfaces opportunities within an hour of connection. Applied optimizations typically pay back their cost within a few months, with the published GigaOm report noting double-digit percentage reductions in cloud spend across customers.

Q: Is Akamas open source? A: No. The reinforcement learning engine is proprietary and patented. Documentation and SDKs are public, but the optimizer itself is closed.

Conclusion

Akamas is one of the more compelling “AI for DevOps” products in 2026. The combination of a real production-grade platform (KubeCon speaker, GigaOm Leader, Italian soonicorn), a focused full-stack optimization scope, and a real customer base puts it in a different category from the agent frameworks and copilots that dominate HN’s front page. If you are running Java or Node.js on Kubernetes at scale and have already exhausted the easy wins from Karpenter and VPA, Akamas is worth a serious evaluation.

For more, see the Akamas Insights announcement, the KubeCon EMEA 2026 HPA-aware optimization post, and the GigaOm Radar report.