> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cnap.tech/llms.txt
> Use this file to discover all available pages before exploring further.

# Resource Audit

> Cluster-wide CPU/memory capacity report in 56ms from a single API call

An agent asked to "count all resource requests and limits across all pods" returned a full capacity report in **56ms** — from a **single API call**. All the computation happened inside the sandbox.

## The Numbers

| Metric                        | Value    |
| ----------------------------- | -------- |
| Total time                    | **56ms** |
| API calls made inside sandbox | 1        |
| Pods analyzed                 | 11       |
| Tool calls seen by the LLM    | **1**    |

## The Code

```js expandable theme={null}
async () => {
  const clusterId = "cls_abc123"; // resolved by the agent from conversation

  const allPods = await cnap.request({
    method: "GET",
    path: `/v1/clusters/${clusterId}/kube/api/v1/pods`,
  }).then(r => r.body);

  // Unit parsers — written by the agent, executed in the sandbox
  const parseCpu = (v) => {
    if (!v) return 0;
    if (v.endsWith("m")) return parseInt(v) / 1000;
    return parseFloat(v);
  };
  const parseMem = (v) => {
    if (!v) return 0;
    if (v.endsWith("Gi")) return parseFloat(v) * 1024;
    if (v.endsWith("Mi")) return parseFloat(v);
    if (v.endsWith("Ki")) return parseFloat(v) / 1024;
    return parseFloat(v) / (1024 * 1024);
  };

  const totals = { requests: { cpu: 0, memMi: 0 }, limits: { cpu: 0, memMi: 0 } };
  const perPod = [];

  for (const pod of allPods.items.filter(p => p.status.phase === "Running")) {
    const podRes = { requests: { cpu: 0, memMi: 0 }, limits: { cpu: 0, memMi: 0 } };
    for (const c of pod.spec.containers) {
      const r = c.resources || {};
      podRes.requests.cpu += parseCpu(r.requests?.cpu);
      podRes.requests.memMi += parseMem(r.requests?.memory);
      podRes.limits.cpu += parseCpu(r.limits?.cpu);
      podRes.limits.memMi += parseMem(r.limits?.memory);
    }
    totals.requests.cpu += podRes.requests.cpu;
    totals.requests.memMi += podRes.requests.memMi;
    totals.limits.cpu += podRes.limits.cpu;
    totals.limits.memMi += podRes.limits.memMi;
    perPod.push({
      pod: pod.metadata.name,
      ns: pod.metadata.namespace,
      requests: { cpu: `${Math.round(podRes.requests.cpu * 1000)}m`, mem: `${Math.round(podRes.requests.memMi)}Mi` },
      limits: { cpu: `${Math.round(podRes.limits.cpu * 1000)}m`, mem: `${Math.round(podRes.limits.memMi)}Mi` },
    });
  }

  return {
    pod_count: perPod.length,
    totals: {
      requests: { cpu: `${Math.round(totals.requests.cpu * 1000)}m`, mem: `${Math.round(totals.requests.memMi)}Mi` },
      limits: { cpu: `${Math.round(totals.limits.cpu * 1000)}m`, mem: `${Math.round(totals.limits.memMi)}Mi` },
    },
    per_pod: perPod.sort((a, b) => parseInt(b.requests.mem) - parseInt(a.requests.mem)),
  };
}
```

## Why This Matters

The Kubernetes API returns raw pod specs — CPU in millicores (`"100m"`), memory in mixed units (`"256Mi"`, `"1Gi"`, `"131072Ki"`). A traditional MCP tool would dump all that raw JSON into the LLM's context and hope it can do math.

Code Mode puts the computation in the sandbox. The agent wrote unit parsers for CPU and memory, iterated every container in every running pod, aggregated totals, and returned a clean capacity report. The LLM context received a sorted summary — not the raw specs of 11 pods.

## What the Agent Does

1. Fetches all pods across all namespaces (single API call)
2. Writes CPU millicore and memory unit parsers
3. Iterates every container in every running pod
4. Aggregates requests and limits per-pod and cluster-wide
5. Converts back to human-readable units, sorts by memory
6. Returns a formatted capacity report