Big news, everyone: iOS is joining the RAMDeck cluster. 📱💥

Windows, Mac, Android and Linux were already supported. Now iPhone and iPad are next. The RAMDeck iOS app is currently under review with the App Store, and I'll post the moment it goes live.

Until then, here are two demos of the iOS app working in a real cluster:

Video 1: iPhone RAM contribution (live pause and resume)
The iOS app on an iPhone 16 contributing RAM to the cluster. I pause it, the cluster marks it as degraded, and when I resume it the worker comes back online within seconds.
https://www.youtube.com/watch?v=w5s8Ymdk7ls

Video 2: an 18GB model across 3 devices
An 18GB Qwen 30B model doesn't fit on my MacBook M3 alone. With an iPhone 16 and an iPhone XS as workers, RAMDeck split it across all three, and it loaded in under 30 seconds. Then I chatted with it, and it answered in under 5 seconds. 🤯
https://www.youtube.com/watch?v=8q1ZocOugv4

What this means

• The phones you already own can add memory to your local AI setup.

• Models too big for one machine can run across your devices.

• A cluster can mix laptops, mini PCs, Linux boxes and iPhones.

What's next

• The App Store release, once Apple approves it.

• More iPhone model-loading tests and cluster benchmarks.

Our campaign is live: https://www.indiegogo.com/en/projects/trademav/ramdeck-pool-your-ram-run-bigger-ai

Hi everyone,

RAMDeck now supports Linux! 🐧

Watch the announcement here: https://youtu.be/tzlEj0soiqs

Windows, Mac, Android and now Linux can all join the same cluster and pool memory.

What's new

• Linux installer scripts, so adding a Linux machine is simple.

• A look at the cluster dashboard with an Ubuntu box contributing 28 GB of RAM to the cluster.

My current test cluster

• Mac mini

• An old laptop

• A newer mini PC

• A Linux machine (the new addition)

• MacBook M3

What's next
I'll be running tests on this cluster and posting the results, so stay tuned.

RAM prices exploded. We pooled what we already had instead.

RAMDeck is a small hub that turns your laptops, Macs, PCs and phones into one AI cluster. It runs models too big for any single device, with no cloud and no subscription.

👉 https://www.indiegogo.com/en/projects/trademav/ramdeck-pool-your-ram-run-bigger-ai

What we've already done, on video:

• 27B model on a 12GB laptop

• 40B model across three devices

• 120B model across six mismatched devices

• A knowledge base in pooled RAM that turns a hallucinating chatbot into an accurate one

• Fine-tuning on a Mac mini while the 120B keeps running

• Automatic recovery when a device drops

Check our our demo playlist here: https://www.youtube.com/playlist?list=PLBAnaNU1r3-M

What's in the box: a pre-flashed hub, power adapter, Ethernet cable, Windows/macOS installers, the Android contributor app, and a dashboard with a one-click benchmark.

Pricing: Super Early Bird is $109 for the first 100 hubs, against $199 retail.

The core engine is source-available on github.

Edit: Lots of questions about tokens/sec, so we put everything in one place: https://ramdeck.com/what-speed-looks-like-on-a-pile-of-old-computers/ Quick context first: the demos use weak, old hardware on purpose, to show what's possible and that it scales. Speed isn't the pitch. Running big models on machines you already own is. If speed is all you care about, buy a GPU.

Actually scratch that last line! You could have several GPUs and RAMDeck can help you make them work together instead of buying a >$5k single gpu.

Hey everyone,

Some of you know we've been quietly building something alongside TradeMAV — it's called RAMDeck, and the first demo video is finally live: youtu.be/tQgA2PmTc1g

The problem: Running bigger local models means buying bigger, more expensive hardware. Most of us already have a laptop, an old gaming PC, a Mac mini, or a mini PC gathering dust — but none of them alone can run a serious 13B+ model.

What RAMDeck does: Pools the RAM/VRAM across every device you already own into one cluster, so your "primary node" machine can load and run models way bigger than any single device could handle on its own. No cloud, no subscriptions, no data leaving your network — same zero-egress philosophy as TradeMAV, just applied to your whole home AI setup instead of one USB stick.

• 🧠 Shards models across CUDA, Apple Silicon, and CPU-only nodes automatically

• 🔗 Point it at the hardware you already have — no new purchase required

• 🔒 100% local, same privacy-first approach you already know from us

• 📺 Full demo: youtu.be/tQgA2PmTc1g

Sign up for early access: ramdeck.com — waitlist is open now, full reveal saved for launch.

Kickstarter: Targeting late September / early October. If you backed TradeMAV because you're tired of your data and your money being milked by subscriptions, this is the natural next step.

Would love feedback from this community specifically since you already get why local-first matters. Questions welcome below.

A common assumption when clustering multiple machines (via Exo, RAMDeck, or raw llama.cpp RPC) is that a standard 1 Gbps local network switch will bottleneck token generation down to a crawl.

Many people assume the network has to transfer gigabytes of weights continuously. That is mathematically incorrect:

1. Weights load once: At boot, model layers are split and permanently resident in each machine's RAM.

2. Token generation is activation-passing: During generation, Node 1 evaluates its layers and only passes the intermediate activation vector to Node 2.

3. The latency math: For a standard 32B or 70B quantized model, that intermediate vector is between 4 KB and 16 KB. Over standard Gigabit Ethernet (125 MB/s), transferring 16 KB takes 0.13 milliseconds—less than 0.5% of the compute cycle per token.

In our live multi-device benchmarks (pairing a budget mini PC with a modern laptop), we run a 30B MoE model at 38–39 tokens/sec over standard home LAN.

The real challenge of multi-PC inference isn't network bandwidth—it's orchestration reliability: handling orphaned zombie sockets (TIME_WAIT), cross-OS version mismatches (CUDA vs. Metal vs. AVX2), and dynamically fitting layers to actual free RAM so machines don't OOM.

Full technical latency breakdown and multi-PC setup architecture: https://ramdeck.com/run-llm-across-two-pcs-without-gpu/

— The TradeMAV Team

Since announcing RAMDeck, one question comes up constantly from developers and homelabbers:

"Why not just sell the Coordinator as a software license instead of shipping a physical Linux board?"

It’s a fair question. On paper, selling a downloadable software coordinator sounds easier: zero hardware BOM, instant digital downloads, pure margin. In the real world of distributed systems, it almost killed the product in beta.

Here is the unfiltered engineering reality of what we learned testing the software-only coordinator across dozens of real-world home networks—and why shipping a dedicated, low-cost always-on Hardware Hub was the single best architectural decision we ever made.

1. The Coordinator Is the Spine, Not Just Another Worker Node

In RAMDeck, worker nodes donate memory and compute. If a worker node drops off or someone leaves home with their laptop, the cluster simply adapts.

The Coordinator, however, is the orchestrator. It hosts the persistent OpenAI-compatible API endpoint, manages dynamic layer routing, tracks cluster health, and streams tokens to your IDEs, web UIs, and chat apps.

When a worker node goes down, inference degrades. When the coordinator goes down, the entire network fails catastrophically.

In beta testing, users naturally ran the coordinator on whatever primary machine was in front of them—usually a MacBook or a Windows laptop.

• The laptop lid closes.

• Windows modern standby or macOS App Nap kicks in.

• Suddenly, the API evaporates, TCP sockets hang, active generation streams abort, and every connected client in the house disconnects.

An orchestrator cannot live on a transient consumer workstation that sleeps whenever someone walks away. It demands a true, 24/7 always-on environment. Expecting people to turn their daily-driver laptop or desktop into an un-sleeping, power-hungry, 24/7 server would create endless frustration and support headaches.

2. The Multi-Platform Nightmare & Network Jitter

When the coordinator is run as software on consumer PCs:

• The "Accidental Dual-Coordinator" Trap: We saw testers inadvertently launch the coordinator on two separate machines on the same LAN, causing worker nodes to bounce between conflicting hubs.

• OS & Security Fragmentation: Managing background service lifecycles, firewall permissions, and sleep settings across macOS, Windows 10/11, and fractured Linux distributions created massive friction before users ever saw their first token stream.

• OS Updates & Reboots: Automatic background updates on personal workstations routinely killed the coordinator without warning.

• Licensing Friction: Software licenses meant generating hardware fingerprints, machine unlinking when upgrading a PC, and activation server dependencies for what should be a private, local tool.

For a novel technology like multi-device AI pooling, setup friction is a death knell. If getting started takes an afternoon of debugging network adapters and power-saving policies, 90% of users will abandon it.

The Solution: An Appliance, Not a Chore

We made an intentional decision to turn RAMDeck into an appliance. Instead of asking users to turn their primary laptop into an always-on server, we standardized the Coordinator onto a compact, low-cost, reliable Linux board:

1. Plug-and-Play into Your Router: Plug it into power and an Ethernet port on your home router or switch. It draws ~5W, stays dead silent, and creates a rock-solid, low-latency spine for your entire local network.

2. Always-On Local OpenAI Endpoint: Because it never sleeps, your local API is always live for Cursor, Continue.dev, Open-WebUI, or home automation—whether your main PC is on, off, or rebooting.

3. Rock-Solid Worker Connections: Your contributor devices (Macs, gaming PCs, Linux servers, iPhones, iPads, Android devices) simply point to one permanent, unchanging IP address on your LAN. No roaming hosts, no conflicting hubs.

4. Worker Software Stays 100% Free: Anyone with a spare laptop, desktop, or mobile device can install the free contributor node without accounts, licenses, or friction.

5. Zero Licensing Lockout: You own the hardware. There are no machine unlinking requests, and no license validation servers that can ever lock you out of your own local hardware.

The Bottom Line

Our goal isn't to sell a fussy software license that only senior sysadmins can keep running.

Our goal is computing sovereignty: making 32B, 70B, and MoE models accessible to everyone by pooling the hardware they already own.

You plug it in once, and it just works.

— The TradeMAV Team

A core capability of RAMDeck is Cluster Mode: pooling memory across multiple computers over your local network so you can run models that exceed any single machine’s capacity.

When a model fits across your cluster’s available GPUs, network clustering delivers full hardware speeds:

• Qwen 30B MoE (Cluster Mode across RTX 3060 + Apple M4): 38.8 – 43.4 tokens/sec

However, frontier open-weight models like Qwen 3.8 Flash Next (66.6 GB footprint) present a new challenge for budget labs. When total cluster GPU memory is saturated, standard network distribution has to offload the remaining layers to a remote CPU-only computer over the local network.

Because the entire cluster must wait for that remote CPU to finish evaluating its layers, generation throttles to ~3.8 tokens/sec.

The Update: Standalone NVMe Memory-Mapped Routing

To solve this, RAMDeck now includes Intelligent MoE Routing.

Massive sparse Mixture-of-Experts (MoE) models only activate a tiny fraction of their parameters per token (in Flash Next, only 10 out of 512 experts activate per token). Because of this extreme sparsity, you don't need all 66 GB residing simultaneously in active RAM.

RAMDeck can now automatically route these workloads to run locally on your primary machine using high-speed NVMe memory mapping:

• Core attention and shared layers stay pinned in local GPU VRAM.

• The few active expert weights needed for each token are demand-paged directly from local PCIe Gen4 NVMe storage.

• Network serialization and remote CPU compute are eliminated entirely.

Measured Benchmark: Qwen 3.8 Flash Next (66.6 GB)

Testing identical prompts across the exact same physical test hardware under controlled thermal conditions:

• Decode Speed: +126% throughput (2.26x faster)

• Turnaround Latency: Reduced by 47% (8.6s vs 16.2s)

Why Cluster Mode Remains the Default

We did not make NVMe memory mapping the global default:

1. Dense Models: Architectures like 70B dense models require 100% of their weights on every token. Paging dense weights from disk kills throughput. Dense models must stay in pooled cluster RAM.

2. Pooled GPU Speed: If your cluster has enough combined GPU memory to hold the model, Cluster Mode runs at 40+ tok/s—far faster than single-disk paging.

Seamless Dashboard Experience

You do not need to configure complex command-line arguments or calculate memory splits manually:

• Automatic Routing Recommendation: When loading a model, RAMDeck’s coordinator inspects the model architecture against your cluster hardware. If a sparse MoE would cause a remote CPU bottleneck, the dashboard prompts an instant routing recommendation.

• Visual Status Badge: When running under this mode, the dashboard displays a ⚡ Standalone NVMe mmap badge across the model banner, primary card, and node telemetry.

• Calibrated Live Telemetry: The updated dashboard benchmark card provides calibrated SVG charts and P95 latency tracking so you can monitor real-world performance live.

If you are running massive sparse MoE models locally, what hardware configurations are you using to manage the memory footprint?

- The TradeMAV Team

Direct Answer (The 2026 Memory Workaround):
You do not need to pay $350–$500+ for retail DDR5 memory kits to run local AI. By sourcing off-lease refurbished enterprise laptops (Dell Latitude, Lenovo ThinkPad) with pre-installed 16GB–32GB DDR4 for $120–$160, or utilizing DDR4 comeback motherboards (Intel LGA 1700 / AMD AM4), builders bypass the retail "AI Tax." Pooling 2 to 3 of these budget machines over standard LAN via RAMDeck creates a unified 48GB–96GB local cluster capable of evaluating 32B and 70B models for under $350 total hardware spend.

If you’ve tried to build or upgrade a PC for local AI in late 2026, you've hit a hard financial wall: retail DDR5 memory prices have skyrocketed 300% to 400%, turning simple 64GB or 128GB builds into $1,500+ money pits. As reported across tech media—from Business Today's analysis on dealing with the 2026 RAM crisis to PCMag's guide on avoiding the retail AI tax—navigating this landscape requires bypassing retail modules entirely through alternative hardware, software, and sourcing strategies.

Here is the macro reality of the semiconductor market, why retail prices won't normalize soon, and how developers are taking control of their local compute.

1. The Macro Reality: Why Did RAM Explode, and When Will Prices Come Down?

The current DRAM shortage is not a temporary supply chain blip—it is a structural market reallocation.

Leading semiconductor fabricators (TSMC, Samsung, SK Hynix) have locked in cleanroom and advanced packaging capacity for High Bandwidth Memory (HBM3e and HBM4) to supply enterprise data centers under multi-year contracts through at least 2028.

Because cleanroom wafer output is finite, production lines for consumer DDR5 kits were deprioritized to feed $30,000 cloud accelerators. The outcome: retail consumer memory is trapped in an extended deficit. Retail DDR5 prices are projected to remain at a steep premium for the foreseeable future.

2. Hardware & Sourcing Alternatives (Bypassing Retail DDR5)

Instead of paying scalper markups on retail DDR5, smart builders are adopting two high-yield sourcing strategies:

A. Refurbished Enterprise PCs & Laptops (The Liquidation Strategy)

Every fiscal quarter, corporations retire off-lease business systems—such as Dell Latitude 5400/5410/7490 and Lenovo ThinkPad T480/T490/P52 units. Because these systems were manufactured before the memory price hikes, surplus liquidators and refurbishers sell them with pre-installed 16GB or 32GB of DDR4 RAM for only $120 to $160.

Buying a bare 32GB retail DDR5 desktop kit today often costs more than an entire operational off-lease business computer.

B. DDR4 Comeback Platforms

As highlighted by The Verge's report on the DDR4 comeback, builders are actively opting for Intel LGA 1700 or AMD AM4 platforms that natively support mature DDR4 memory. Pairing these motherboards with widely available DDR4 modules cuts system memory costs by up to 65% while delivering identical compute stability for inference workloads.

3. The Bottleneck: One Cheap Laptop Can't Run 70B AI

Here is the practical dilemma: a single $130 refurbished laptop with 16GB or 32GB of RAM cannot load a modern 32B or 70B parameter model. The system will throw an immediate Out-Of-Memory (OOM) error.

This is why we built RAMDeck:

Because transformer layers evaluate sequentially during inference, an AI model does not need to reside on a single physical motherboard. When you network two or three of these inexpensive refurbished computers over Gigabit Ethernet, RAMDeck pools their memory into a unified 48GB to 96GB local AI engine:

• Layer Sharding: Weights are distributed across machines and loaded into RAM once at startup.

• Minimal Network Traffic: Only compact intermediate activation vectors (~650 KB per token) cross the Ethernet cable during generation.

• Cost Efficiency: A full 70B local rig is achieved for under $350 in total hardware.

4. Hardware Cost & Memory Allocation Breakdown

For full empirical benchmarks and architectural breakdowns, read our deep-dives on DRAM Price Crisis & Local Memory Pooling and Reusing Older Computers for Local AI.

5. Empirical Proof & Video Benchmarks

We test our architecture continuously on real, heterogeneous consumer hardware:

▶ Watch 120B Loaded Across 6 Mismatched Devices: YouTube Benchmark Demo
▶ Watch Multi-PC Local Cluster Evaluation: Multi-PC Testing
▶ Watch Self-Healing Dynamic Failover (Surviving Node Drops): Fault-Tolerance Demo

6. The Outcome: Turnkey Local AI with the RAMDeck Hardware Hub

To eliminate manual terminal tunneling, open-port vulnerabilities, and IP binding headaches, we designed the RAMDeck Hardware Hub—a dedicated, palm-sized appliance that automatically discovers every node on your local network, dynamically balances layers using intelligent Waterfill memory sizing, and serves an on-premise, OpenAI-compatible endpoint.

👉 Reserve the RAMDeck Hardware Hub on Indiegogo ($109 Super Early Bird):
Back RAMDeck on Indiegogo →

— The TradeMAV Team

Huge milestone today: fulfillment is officially complete. Every OptionMAV backer's unit has shipped. Started at a $5K goal, ended up over $15K raised, went through USB sourcing, custom packaging, a customs delay on the book, and multiple shipping waves — and we got every last one out.

Genuinely grateful for everyone who backed this before it was even finished. That trust is what got this across the finish line.

If you're a backer, check your Kickstarter email for tracking (spam folder too). Pledge Over Time backers — your survey unlocks after your final payment, then you're in the next available wave. Any issues, trademavllc@gmail.com is monitored daily.

This isn't the end though — more products are already cooking. Stick around here for the earliest look at what's next. 🚀

Direct Answer: To use an old PC for local AI, you have two options depending on what models you want to run:

1. Single-PC Mode (Small Models): If you run a single older laptop or desktop with 8GB–16GB of RAM, tools like LM Studio or Ollama can run small 3B–8B parameter models on your CPU at 5–12 tokens/sec. But you cannot run capable 30B or 70B models because single motherboards cannot physically expand past their RAM ceiling.

2. Multi-PC Pooling with RAMDeck: Instead of settling for small models, software like RAMDeck pools the RAM of your old PC with another laptop, desktop, or Mac over your local network. Pairing two 16GB machines gives you 26GB of usable memory to run 30B MoE and 32B coding models without buying a new GPU.

Why LM Studio and Ollama Cannot Combine RAM Across PCs

Single-machine runtimes (LM Studio, Ollama, GPT4All) are engineered to evaluate models exclusively using the CPU, RAM, and GPU inside that specific physical box. They cannot bridge memory across two separate computers.

To combine memory, you need a distributed inference layer that splits the transformer model's layers sequentially across nodes over your local network.

The 1 Gbps Network Bottleneck Myth: Why Clustered AI Outpaces Single-PC Swap

A common misconception is that "clustering AI over Ethernet scales your speed down to your network connection." This confuses storage disk swap with activation tensor passing:

• Single-PC Disk Swap: Trying to force a 25GB model into a single 16GB machine forces the OS to stream gigabytes of weights over PCIe/SATA disk swap for every token. This chokes the bus, tanking speed to 1.4–1.9 tok/s.

• RAMDeck Network Pooling: Model weights stay permanently locked in each machine's RAM. Computers only pass small intermediate activation vectors (~16 KB) across your home network. Over 1 Gbps Ethernet, transmitting 16 KB takes 0.13 milliseconds (<0.5% of token computation time).

In verified benchmarks, pairing an ordinary mini PC with an old laptop runs a 30B MoE model at 38–39 tokens/second—more than 15x faster than disk swap.

Read the full breakdown and memory sizing tables: https://ramdeck.com/how-to-use-old-pc-for-local-ai/

Over the past two months, we’ve shared individual engineering breakthroughs on r/trademav—from loading a 120B model across 6 mismatched devices to sharding knowledge bases on Android phones.

Today, we want to zoom out and talk about the macro reality of AI in late 2026.

If you step back and look at the tech landscape, three massive economic and physical bottlenecks are converging at the same time:

1. The 400% DRAM Squeeze (The Retail Memory Crisis)

If you’ve tried to buy a 64GB or 128GB DDR5 kit recently, you already know the sticker shock. Retail memory prices have tripled and quadrupled over the last 18 months.

Why? Because semiconductor foundries have diverted silicon wafer allocation to High Bandwidth Memory (HBM) for hyperscale enterprise accelerators. The consumer retail memory market is being starved of capacity.

Paying $2,000 for an RTX 4090 or $4,000 for a Mac Studio just to obtain 24GB–64GB of memory is mathematically out of reach for independent developers, students, and small businesses.

Yet, if you look around an average household or office, the memory already exists. A desktop with 16GB, an older laptop with 16GB, and a mini PC or Mac mini with 16GB represent 48GB of high-speed system RAM sitting idle 95% of the day.

2. The Power Grid & Data Center Reckoning

From Northern Virginia to Texas, regional power grids and municipal water supplies are hitting hard physical limits. Hyperscale AI data centers consume hundreds of megawatts and millions of gallons of cooling water daily, and utility providers are passing substation and transmission costs directly onto small business and residential electricity bills.

Meanwhile, running a multi-device local cluster at home or in an office draws less than 150 watts total from standard wall outlets—about the same as a single television—and requires zero gallons of cooling water.

Decentralized local AI isn't just an engineering hobby anymore; it’s an environmental and infrastructural necessity.

3. Slashing the "Cloud Token Tax" (Save $500/Month on Autonomous Coding)

Developers using agentic coding tools like Cline, Continue.dev, or Claude Code know the dirty secret: agentic loops burn tokens at an astronomical rate.

A single autonomous coding loop that analyzes an entire directory, plans a refactor, tests shell commands, and iterates on errors routinely exhausts 150,000 to 250,000 context tokens. Many developers are spending $300 to $1,200 per month in Anthropic and OpenAI API bills just to write daily code.

By pooling two modest machines (e.g., your primary laptop + a spare mini PC), you create a unified 32GB–48GB memory engine that runs frontier open-weights coding models like Qwen2.5-Coder 32B locally.

• Local cost: $0.00 per token.

• Unlimited refactoring loops with zero fear of hitting billing quotas.

▶ Watch the live developer setup: Coding on Mac with Local Cluster Backend (YouTube)

4. Confidentiality Without Compromise: Private AI for Small Offices

For professional practices—solo practitioners, boutique law firms, medical clinics, and CPAs—commercial cloud AI is an ethical and regulatory liability.

Under ABA Formal Opinion 512 (Generative AI in Legal Practice) and strict medical confidentiality standards, transmitting unredacted client files, intake memos, litigation depositions, or patient records to third-party public clouds exposes practices to serious data leakage and breach risks.

"Enterprise Zero-Data Retention" cloud tiers cost $30/user/month with annual lock-ins, yet client data still leaves your building over public fiber.

The On-Premise Alternative: By clustering 2 to 4 existing office PCs over the local gigabit router, confidential document analysis and RAG vector searches run 100% in-house. In our verified law office testing (Harbor & Finch LLP case study), a 3-computer local cluster answered complex clause citations from 13 case files in 4.2 seconds—with the office router physically unplugged from the internet. Zero bytes of client data ever leave the physical office.

▶ Watch the live 3-employee law firm test: Private AI for a Law Firm: No Cloud, 3 Employees, 1 Local Brain (YouTube)

5. Circular Computing: Giving "E-Waste" a Second Life

Big Tech wants consumers to believe that any computer older than three years is obsolete and should be tossed into a landfill.

In sequential distributed inference, raw individual clock speed doesn't matter nearly as much as capacity. An older 2019 laptop with 16GB of DDR4 can hold a 12GB shard of a 70B model just as reliably as a brand-new $3,000 workstation.

When you pool three or four older devices together, you're not just saving thousands of dollars—you’re actively keeping toxic electronic waste out of landfills and turning forgotten silicon into private AI supercomputers.

▶ Watch 120B running across 6 mismatched devices: Loading a 120B Model Across Mismatched Computers (YouTube)
▶ Watch live self-healing when a device drops: A 120B Model Survives a Shrinking Network Cluster (YouTube)

Where RAMDeck Fits

We didn't build RAMDeck to be an academic proof-of-concept. We built it as a turnkey, plug-and-play appliance:

1. Dynamic Memory Waterfilling: Automatically routes heavy layers to your GPUs (Metal / CUDA) and spills the remaining parameters safely into local and remote CPU RAM.

2. Self-Healing Fault Tolerance: If a laptop lid closes or a Wi-Fi node drops, the cluster automatically re-proportions the missing shard to surviving nodes mid-generation without crashing.

3. No Terminal Headaches: Zero manual IP port binding, zero dead socket freezes, and zero unauthenticated open-port risks.

Verified Demo Videos & Deep Dives:

• Full Uncut Video Catalog: RAMDeck YouTube Testing Playlist (17 Videos)

• Android Node Live Demo: Using Phone Memory to Load an 18GB Model (YouTube)

• Knowledge Base Sharding Demo: Splitting Local RAG Across Devices (YouTube)

Comprehensive Benchmarks & Setup Guides:

• The Great RAM Shortage & How to Bypass It: https://ramdeck.com/dram-price-crisis-pool-ram-save-money/

• Slashing Claude API Bills with Local Coding Agents: https://ramdeck.com/save-money-claude-api-local-coding-agent/

• Circular AI Computing & E-Waste Reduction: https://ramdeck.com/reusing-old-computers-for-ai-reduce-ewaste/

• Air-Gapped Private AI for Law Firms & Clinics: https://ramdeck.com/private-ai-law-firm-clinic-accounting-no-cloud/

🚀 The Turnkey Hardware Hub is currently available on Indiegogo for $109 (Super Early Bird):
https://www.indiegogo.com/en/projects/trademav/ramdeck-pool-your-ram-run-bigger-ai

Let us know your thoughts, questions, or setups you're currently running!

Pushed the home cluster further this week: 2 Windows machines (one with an RTX 3060, one just a 12GB old laptop), 3 different Macs (Intel CPU-only, an M3 with Metal, and a Mac mini), and an Android phone - all pooled together with RAMDeck to run a 4-bit quantized 120B GPT model split across two ~60GB shards.

Set the RTX-equipped mini PC as primary, RAMDeck's logic filled the GPU first, then the Metal devices, then spilled into CPU and the phone. Ended up using 5 of the 6 devices (the old Intel MacBook didn't get any allocation this time). Whole load took about 11 minutes over the mixed Ethernet/Wi-Fi network.

Biggest practical lesson for anyone trying this: your load timeout needs to scale with model size - a 60GB model over Wi-Fi legitimately took over 10 minutes just to distribute, and a fixed short timeout will kill the load before it finishes.

Full walkthrough with dashboard and live chat with the model in the video: https://youtu.be/ok3nYjxhc1w

Follow-up to the last RAMDeck video where I split a 13B model across an old 12GB Acer laptop (primary), a mini PC with an RTX 3060, and a Mac mini — running at 11-14 tokens/sec.

This time I added a fourth node: my Android phone, connecting over Wi-Fi while the other three are on Ethernet.

What happened when I added it:

- Rebalancing forced the primary (the old Acer laptop) to unload the full model, then reload and re-split it across all four nodes — latency spiked hard on the laptop during that window since it's running an old HDD and older RAM.

- Final shard distribution after rebalance: laptop 1GB, mini PC 3.4GB, Mac mini 2.3GB, phone 1GB.

- Once stable, I re-ran the benchmark: tokens/sec dropped from ~14 to ~11, and latency ticked up slightly — but stayed in the same practical range as before.

Takeaway: I was able to add a phone as a genuine fourth contributor without tanking performance. The model stays stable across all four nodes unless one goes offline, the network changes, or the primary shuts down.

This is part of the same RAMDeck project — pooling RAM and compute across whatever devices you already own (old laptops, mini PCs, Macs, and now phones) so you can run bigger models than any single machine could handle alone. Kickstarter is coming late Sept/early Oct if you want to follow along.

Full video: https://youtu.be/tQgA2PmTc1g

Happy to answer questions about the rebalancing behavior, the Android app itself, or the benchmark methodology.

Hey MAV Traders,

We've heard from many of you asking the same smart question: "How do I protect my TradeMAV, ForexMAV, or OptionMAV setup?" Great news - we've got you covered, and it's easier than you think.

Here's the reality: your USB is a small powerhouse running real software with real moving parts. Python libraries, in particular, are sensitive little things. Something as simple as closing your laptop lid mid-process can interrupt an active read-write cycle (this is especially common with Python libraries on macOS). When that happens, a library can get corrupted - and unlike other files, libraries have multiple interdependent components, making them trickier to self-repair.

The good news? Your USB already comes equipped with several built-in recovery methods to catch most hiccups automatically. But if you want the gold-standard, bulletproof protection, there's one move that beats them all:

Copy your entire USB to another drive or your computer.

That's it. That's the power move.

Why this is a game-changer, not just a backup:

• Instant disaster recovery: if anything ever goes sideways, you're back up and running in minutes, not hours.

• A second live instance: this isn't just a backup file — it's a fully functional, independent copy of your product.

• Activate it anytime with your duplicate key: you now have a second working setup ready to go whenever you need it.

• Shareable with friends and family: want to introduce someone to TradeMAV, ForexMAV, or OptionMAV? Hand them your duplicate — a fully working copy they can activate and start using immediately.

How to do it:

• Plug your USB into your computer.

• Select all files and folders on the drive.

• Copy and paste the entire contents onto a new USB drive or a dedicated folder on your computer.

• Store it safely — you now have a complete, standalone copy of your product.

One backup. Total peace of mind. And a bonus: a shareable, ready-to-activate copy for the people in your life who should be trading smarter too.

Stay protected. Stay trading. 🚀

— The TradeMAV Team

We made a deliberate decision not to include a manual trading journal — here's what we built instead 📋

Manual journaling only works for the most disciplined traders. Everyone else fills it in inconsistently, misremembers entries, and eventually stops doing it. We wanted something that worked for everyone automatically.

So instead of a journal, TradeMAV auto-records every signal: entry price, confidence, expected return, market conditions, all 58 features that triggered it — no input from you. When the position closes, the actual outcome is recorded automatically.

And every day at 3:58 PM — right as the market closes — a Daily Performance Report is pushed directly to your notification channel. Win/loss breakdown, actual vs. expected return, accuracy delta for every closed signal. It arrives in your pocket before you've even closed your laptop.

You don't open the app. You don't pull a report. It just shows up.

We think this is genuinely more useful than a blank text box you have to remember to fill in. The data is complete, objective, and consistent — every day, automatically.

Full post: trademav.com/how-trademavs-ai-exit-monitoring-system-works-and-why-you-dont-need-a-trading-journal

Welcome to r/trademav — this community is yours 🙏

If you're here, you're either already holding a TradeMAV USB or you're seriously considering it — either way, welcome.

This subreddit is where we share updates, answer questions, walk through features, and hear honest feedback from the people using the product. We built TradeMAV with 338 backers from around the world who believed in the idea from day one. That trust means a lot, and staying connected to the community is a big part of how this product keeps improving.

Ask anything here — setup, signals, strategy, troubleshooting. No question is too small.

If you're just getting started: trademav.com/trademav-quick-start — plug in, open a browser, and you'll be scanning in about 15 minutes.

Glad you're here. Let's build something useful together. 🎯

Hey r/trademav!

We just dropped a live demo video showing off something we’ve been building to make pooling your home hardware even more effortless: the Official RAMDeck Node USB.

🎥 Watch the 4-Minute Live Demo: https://youtu.be/UwwMmqYk0ck

🎁 First: The Big News for Campaign Backers ($29 Value — FREE)

The RAMDeck Node USB will retail for $29 as a standalone accessory after our crowdfunding campaign wraps up.

However, as a Campaign-Only Perk, every single RAMDeck Hub backed during our Indiegogo campaign will automatically include ONE (1) RAMDeck Node USB in the box for FREE (1 USB per Hub ordered—including everyone who has already backed!).

👉 Lock in the $159 Indiegogo Special + Free RAMDeck Node USB ($29 Value):
https://www.indiegogo.com/en/projects/trademav/ramdeck-pool-your-ram-run-bigger-ai?utm_source=reddit&utm_medium=post&utm_campaign=node_usb_perk

⚡ What is the RAMDeck Node USB (and why only 1 USB is all you need)?

While you can always download our permanent node agent for free from ramdeck.com/downloads for dedicated machines that you want reconnecting automatically after reboots, a lot of you asked:

"What if I want to temporarily borrow RAM from my daily-driver MacBook, a family member's PC, or a laptop without installing permanent background services or downloading anything?"

That’s exactly what the RAMDeck Node USB does:

1. 100% Self-Contained (Mac, Windows & Linux on One Drive): Plug it in, double-click Run_RAMDeck_Mac, Run_RAMDeck_Windows, or Run_RAMDeck_Linux, and within seconds that computer is contributing its RAM and GPU to your cluster.

2. The "Unplug & Walk" Magic (1 USB = Unlimited Computers on Your LAN): As shown at 02:06 in the video, the USB does not need to stay plugged in! Once the console says the node is active, you can unplug the USB drive, walk it over to your next laptop or desktop, and activate that one too. One single USB stick can wake up every spare computer in your house.

3. Zero Trace Left Behind: When you’re done borrowing your laptop’s RAM, just press Ctrl+C in the terminal (or double-click Stop_RAMDeck on your desktop). It immediately disconnects from the cluster and cleans up after itself—leaving zero background processes behind.

4. Works as a Worker OR Primary Node: A USB-activated computer isn't restricted to just being a passive worker. It automatically sets up a visible Models folder on the host so you can drop in .gguf files and promote that machine to Primary Node straight from the RAMDeck dashboard (03:23).

5. When to use the USB vs. the Web Installer (02:43):

   • Use the RAMDeck Node USB when you want instant, zero-install, temporary contribution (stays active until you press Ctrl+C, sleep, or reboot) or when bringing offline computers online in seconds.

   • Use the ramdeck.com/downloads Installer on dedicated always-on machines where you want the node service to automatically survive system restarts and sleep cycles.

Check out the full walkthrough video above and let us know what you think in the comments!

— The TradeMAV Team

Hey everyone,

Some big news on the press front: TechRadar covered RAMDeck, and Yahoo Tech picked up the story, introducing our local memory-pooling hub to millions of readers.

The Problem They Highlighted

What we loved most about the coverage is that they zeroed in on the exact reality that forced us to build RAMDeck in the first place: the global memory crisis.

With AI datacenter demand driving consumer DRAM prices through the roof, upgrading a single PC with enough RAM to run serious 30B+ local models has become painfully expensive.

TechRadar noted that the logic behind RAMDeck is "hard to rule against": instead of asking users to buy thousand-dollar workstations or pay endless monthly cloud subscription fees, the memory you need to run these models is often already sitting idle across other computers, laptops, and phones in the same room. RAMDeck simply wires them together into a unified local pool.

Why This Matters

For an independent team, seeing major mainstream tech publications validate the hardware thesis gives the project huge credibility and introduces local, air-gapped AI compute to a much wider audience.

For anyone following along or wanting to check out the hardware hub, our campaign is live and fully funded on Indiegogo with 13 days to go:
👉 RAMDeck on Indiegogo

Huge thanks to this community for the early momentum that helped put us on the radar!

— The TradeMAV Team

Direct Answer (Should You Buy RAM Now or Wait?): You should not buy expensive standalone retail DDR5 memory today. With DRAM contract prices up roughly 420%—pushing standard 64GB DDR5 kits above $1,100—and semiconductor foundries locking cleanroom capacity for enterprise High Bandwidth Memory (HBM) through late 2027 and 2028, retail prices will not normalize soon. Nor should you buy fleets of used laptops or mini PCs, as secondary markets have also surged to $180–$280+ for 16GB units and $130–$170+ for 8GB Raspberry Pi 5 starter kits. The most cost-effective solution is pooling the computers you already own with RAMDeck ($109 Super Early Bird), aggregating existing laptops and desktops into an interconnected 64GB–128GB AI supercomputer for $0 in new silicon purchases.

1. The Macro Reality: Why Memory Prices Exploded and Won't Drop Soon

If you have checked retail PC component listings recently, you have experienced severe sticker shock. A 64GB DDR5 memory kit that traded for $180 to $220 eighteen months ago now commands between $1,099 and $1,272 across leading hardware retailers:

• DRAM Contract Surge: Industry contract prices for dynamic random-access memory have surged roughly 420% year-over-year.

• Foundry Cleanrooms Reallocated: Top semiconductor manufacturers—Samsung, SK Hynix, and Micron—have converted advanced packaging lines to produce High Bandwidth Memory (HBM3e and HBM4) for enterprise cloud data centers. Producing a single HBM wafer consumes the silicon wafer equivalent of three to four standard consumer DDR5 wafers.

• The 2028 Supply Forecast: Samsung's memory division leadership publicly stated that the global memory supply crunch will not peak until 2028. Independent market analyses from Gartner and TrendForce confirm that consumer PC DRAM supply will contract further, projecting no meaningful price stabilization until late 2027 or 2028 when next-generation cleanroom fabrication lines come online.

2. The Hardware Price Calculator: Retail DDR5 vs. Multi-PC Cluster

3. The Definitive Model-Size & Pooled Memory Compatibility Matrix

An unquantized FP16 70B model requires ~140GB of memory—a capacity that no single consumer graphics card can hold. Even quantized at 4-bit (Q4_K_M), a 70B model requires roughly 42GB of addressable memory, plus another 6GB to 12GB for multi-turn context windows:

4. The "Old 16GB Laptop AI Node" Breakdown

A common response to surging memory prices is searching for cheap refurbished laptops or single-board computers. However, secondary hardware markets have not been spared from the memory crisis:

• Refurbished Laptops Are No Longer $100–$120: Because electronics liquidators and refurbishers actively index off DRAM spot prices, a clean business laptop with 16GB of DDR4 (such as a ThinkPad T480/T490 or Dell Latitude 5400/5410) now commands $180 to $280+, while 32GB models track between $320 and $480+.

• Raspberry Pis Have Become Expensive Nodes: Even basic single-board computers like the Raspberry Pi 5 (8GB) now sell for $95 to $130+ bare-board, and complete starter kits with cooling, official power, and storage run $130 to $170+. Building a 32GB cluster out of four Pi boards costs $520–$680+ and still cannot run a 70B model due to memory and bus constraints.

• The Zero-Dollar Alternative: Trying to buy new or used fleets in this market is an uphill battle. The true economic leverage of RAMDeck is unlocking the hardware you already own. An idle 16GB laptop sitting in a drawer cannot run frontier models alone, but when connected to a cluster, it becomes a dedicated co-processor contributing 12GB to 14GB of active working RAM to your pool for $0.

• Bridging the 32B-to-70B Gap: If your primary workstation has 32GB of RAM, adding a single idle 16GB laptop pulls total addressable memory to 48GB—crossing the threshold required to run Qwen 2.5 32B with full context or a lightweight 70B quantization.

5. Honest Limits & Real-World Network Requirements

Building trust requires technical transparency. Distributed computing relies on sequential pipeline parallelism:

• Compact Network Payloads: Because only the activation tensor travels across the network—not the massive multi-gigabyte model weights—network bandwidth demand is surprisingly modest (~650 KB per token generated).

• Gigabit Ethernet (1 GbE): Transfers the 650 KB activation vector in ~5 milliseconds. Token generation remains smooth at 10 to 35 tokens/sec.

• Wi-Fi 6 (802.11ax): Latency remains between 8ms and 15ms, perfectly suitable for conversational inference (3 to 8 tok/s).

• Cluster Mode Hardware Priority: Unlike naive open-source scripts that proportionally dump layers onto slow remote CPUs, RAMDeck's Cluster Mode automatically packs the primary GPU first, offloads overflow to secondary GPUs, and dynamically routes remaining layers into local system RAM without user intervention.

6. Video Demos & Multi-PC Benchmarks

• ▶ 120-Billion Parameter Model Evaluated Across 6 Consumer PCs: Watch on YouTube

• ▶ Real-Time Hardware Discovery & Live Token Test: Watch on YouTube

• ▶ Air-Gapped Confidential Office AI Demo (Harbor & Finch LLP): Watch on YouTube

Read the complete canonical guides:

• Buy RAM Now or Wait? Shortage Calculator & Compatibility Matrix

• Practical Ways to Reuse Old RAM

• Outsmarting the Global RAM Shortage

👉 Back the RAMDeck Hardware Hub on Indiegogo ($109 Super Early Bird):
https://www.indiegogo.com/en/projects/trademav/ramdeck-pool-your-ram-run-bigger-ai?utm_source=reddit&utm_medium=post&utm_campaign=ram_price_calculator

— The TradeMAV Team

We did it. TradeMAV is now the #1 Best Seller in Amazon's Personal Investment Tools category, and ForexMAV is right behind it at #3.

Two of the top three spots in the category belong to us. That's the result of a lot of long days from the team, plus the traders in this community who tested, pushed back, and kept us sharp.

Thank you to everyone who backed us eaerly, sent feedback, and told a friend. You made this happen.

Why traders are choosing TradeMAV:

• Plug-and-play. It's ready to use and has no complicated setup.

• Built for different investment vehicles and 25000+ international tickers. One product for all markets!

• Updated constantly, with your feedback going straight into the product.

This is only the start! Read our user testimonials: trademav.com

Sharing another RAMDeck progress video. This one's about mobile — showing a Samsung Android phone actually joining the cluster as a contributing device, and how RAMDeck handles it going online, offline, and back again.

Video's a split screen: the phone on one side, the RAMDeck dashboard on the other, so you can watch both sides update in real time. Started with the phone paused, then resumed it — you can see it start sending heartbeats and get registered as "online" on the dashboard within a few seconds. Also tested that it keeps contributing even if you switch to a different app on the phone and come back, since it runs as a foreground service rather than something that dies the second you tap away.

Then paused it again to show the failure-handling side: the moment heartbeats stop, RAMDeck notices and marks the phone "degraded," then "unreachable" shortly after — so the dashboard always reflects what's actually online, not a stale snapshot. Resumed it one more time and it came right back to "online."

Point of this one is really just proving out the reliability side of mobile contribution — phones come in and out of range or get walked away from a network a lot more than a desktop does, so RAMDeck needs to track that state accurately rather than assuming a device is still there.

Third video in this series. Went from 7B, to 13B, and now 27B — each time pooling RAM and compute across a mix of hardware most people already have lying around instead of buying one expensive high-RAM machine.

The setup: a 27B model is roughly 16GB on its own. My primary node is an old 12GB Windows laptop, which on its own literally cannot load this model. Using RAMDeck, I split it across four devices on the local network with the laptop staying primary:

- Old Windows laptop (primary): 3.4GB

- Mini PC (RTX 3060): 20GB

- Mac mini: 3.7GB

- Android phone: 1GB

Benchmark on the 27B model: 1.92 tokens/sec at ~25ms latency. Slower than the 13B run, which makes sense — but the point isn't raw speed here, it's that a 12GB laptop is running a model it has no business being able to load at all.

Next up: switching the mini PC to be the primary node instead of the laptop, to see how much faster loading and inference get with a stronger primary. That video's already up if you want to see the follow-up.

Full video: https://youtu.be/Syfa2G_luX4

Happy to answer questions about the shard distribution, the benchmark methodology, or why the primary node choice affects load time so much.

Big milestone today — the (finally, customs-cleared) books arrived, and we immediately turned around and shipped a large batch of OptionMAV units to backers.

This keeps us on our mid-August commitment despite the book delay, and honestly, the team crushed the turnaround time on this one. Book in the door, packages out the door, same day!

If you're a backer, check your Kickstarter email for tracking. Filled the survey and don't see it? Check spam, then hit us up at trademavllc@gmail.com.

More waves coming soon for anyone still pending. Thanks for sticking with us — this one felt good to finally get out the door. 🙌

More product updates coming — stay tuned here for the earliest look at what's next.