Scale up as you grow — whether you're running one virtual machine or ten thousand.

From GPU-powered inference and Kubernetes to managed databases and storage, get everything you need to build, scale, and deploy intelligent applications.

This textbox defaults to using Markdown to format your answer.
You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!
These answers are provided by our Community. If you find them useful, show some love by clicking the heart. If you run into issues leave a comment, or add your own answer to help others.
Got news, the answer from support this time is the real calculation they made:
Our memory calculation is as follows: (MemTotal - MemFree - Cache) / MemTotal
If I do that math, I get the exact number as the graph is showing. But, I don’t think the calculation is well done. See some information found: (Linux kernel source tree)
Many load balancing and workload placing programs check /proc/meminfo to
estimate how much free memory is available. They generally do this by
adding up "free" and "cached", which was fine ten years ago, but is
pretty much guaranteed to be wrong today.
It is wrong because Cached includes memory that is not freeable as page
cache, for example shared memory segments, tmpfs, and ramfs, and it does
not include reclaimable slab memory, which can take up a large fraction
of system memory on mostly idle systems with lots of files.
Currently, the amount of memory that is available for a new workload,
without pushing the system into swap, can be estimated from MemFree,
Active(file), Inactive(file), and SReclaimable, as well as the "low"
watermarks from /proc/zoneinfo.
However, this may change in the future, and user space really should not
be expected to know kernel internals to come up with an estimate for the
amount of free memory.
It is more convenient to provide such an estimate in /proc/meminfo. If
things change in the future, we only have to change it in one place.
MemAvailable was born
I think that the calculation would be: (MemTotal - MemAvailable) / MemTotal
What do you think?
Folks, if you agree with this please upvote the idea here:
Hi Daniel,
This is an interesting question!
I think that this is already the case. For example, here’s my current memory usage according to the graphs:

It is currently at around 61.41%. It is a small Droplet and the total available RAM is 1006756KB.
So If we do 1006756KB - 61.42%, we would get about 388406KB available RAM. And then if I run the free command I get 382476 which is pretty close to the 388406KB value:
total used free shared buff/cache available
Mem: 1006756 423508 80004 9936 503244 382476

What is the current version of your do-agent? I could suggest upgrading it to the latest version, maybe there are some improvements in how the available RAM is calculated.
Also the do-agent is open source, if you are interested you could take a look at the source code here:
https://github.com/digitalocean/do-agent
If you believe that there is still something wrong with the calculation, I would suggest creating an issue in GitHub.
Regards, Bobby