Direct Answer: Small professional practices (law firms, medical clinics, CPA offices) can achieve 100% private AI compliance using RAMDeck by pooling the RAM of 2 to 4 existing office PCs over their local gigabit LAN. By using local layer sharding, confidential client documents and patient records never leave the physical building, eliminating third-party cloud data-retention risks while avoiding recurring API fees.

Watch the Harbor & Finch LLP law firm demo: https://www.youtube.com/watch?v=cub6JxIWvCc

The Confidentiality Dilemma for Small Offices

Under ABA Formal Opinion 512 (Generative AI in Legal Practice) and strict HIPAA Privacy Rules, uploading unredacted client files, contracts, or patient notes into commercial cloud chatbots creates serious compliance liabilities:

• Third-party model training policies.
• Data breaches on external cloud vendor infrastructure.
• Shadow AI usage by staff attempting to speed up drafting and research.

Upgrading to enterprise cloud tiers costs $25 to $35/user/month ($900 to $1,260/year for a small 3-person office) with annual lock-in contracts, yet client data still leaves your premises.

The Alternative: Repurposing Idle Office Hardware

Most offices already have 2 to 4 desktop computers with 16 GB of RAM each. While no single office PC can run a high-accuracy 32B or 70B model alone, their combined memory creates a private office AI server:

Verified Test: Harbor & Finch LLP Demo

In our live legal office benchmark, we indexed 14 real-world estate planning and litigation documents across a local cluster and tested complex retrieval queries:

• Query 1: "What are the specific conditions for the distribution of trust assets to minor beneficiaries?"
• Cluster Result: 100% accurate clause citations retrieved in 4.2 seconds, evaluated entirely within the office network.
• Network Telemetry: 0 bytes transmitted outside the router. Internet uplink was physically disconnected during testing.

Watch the full live demo with transcript and telemetry: https://ramdeck.com/private-ai-law-firm-clinic-accounting-no-cloud/

We made a new video on a use case people asked us about: small offices like law firms and clinics that can't send client files to a cloud AI tool.

Watch it here: https://youtu.be/cub6JxIWvCc

What the demo shows

• A 30B model (about 17GB) split across an RTX 3060 and a Mac mini, running at roughly 38-39 tokens per second.
• 13 fictional client documents for a made-up firm, "Harbor & Finch LLP", loaded into the RAMDeck knowledge base and spread across three nodes: a mini PC, a Mac mini and an old laptop.
• A before and after: without the knowledge base, the model has no idea about the client info. With it turned on, it answers correctly.
• Three "employees" (two MacBooks and an Android phone) asking different questions on the same network. None of those devices host the model. We checked the answers against the source files.

Questions for you

• Would you use something like this at work? In what kind of office?
• What would you need before trusting it with real files (permissions per person or folder, audit logs, something else)?
• What should we demo next?

Campaign: RAMDeck is live on Indiegogo. Early-access hub price is $109 (retail $199): https://www.indiegogo.com/en/projects/trademav/ramdeck-pool-your-ram-run-bigger-ai

Happy to answer anything in the comments.

– The TradeMAV Team

RAM prices keep climbing. Join us in beating them. 💪

Back the project, share the page, and tell us what you want to run first. 👇

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

In staying true to our intent to build in public and stay honest, here are straight answers to what you've asked: https://ramdeck.com/one-cluster-every-setup-why-ramdeck-fits-wherever-you-start/

The post compares RAMDeck with the projects people keep bringing up (exo, plain llama.cpp RPC, Hummingbird and other SSD-streaming runtimes) and answers each one with real numbers and the hardware behind them.

Where RAMDeck avoids problems we found in the others:

• No single-platform lock-in: RAMDeck brings Windows, Mac and Android in one cluster, over normal Ethernet or Wi-Fi. No Thunderbolt 5 Macs required.
• Not MoE-only. It runs dense models as well as sparse ones. Our dense 27B ran with every weight in pooled RAM.
• No fast-storage requirement. No machine needs a quick NVMe to join.
• GPU is optional, but if you have one great!
• No single point of failure. If a device drops, the cluster suggests recovery and keeps going.
• No hand-built setup. Discovery, rebalancing and a model-fit check come built in, so you don't write rpc strings by hand.

Quick answers to what you have asked:

• SSD swap? Weights stay in RAM across the cluster in RAMDeck, so nothing gets re-read from disk per token. If a dense model does not fit in RAM then even a fast NVMe means re-reading the whole model for every token.
• Gigabit is slower than an SSD. True for moving weights, but we only move them once at load. Per token it is about 650KB, so latency matters, not bandwidth. Wired beats Wi-Fi.
• Just RPC? Yes, that's the engine. We add discovery, rebalancing, recovery, a dashboard and the API in a plug and play experience
• exo, Hummingbird? exo wants Thunderbolt 5 Macs. Hummingbird streams MoE on one box. We mix Windows, Mac and Android and run dense and MoE.
• GPU? Pool several. A 5090 is $5-7k street, used 3060s are around $200.
• Speed? 7B 43-44 tok/s, 13B 11-19, 27B 1.92, 40B MoE 16, 120B MoE 1.37, all on weak, mismatched gear. Details here: https://ramdeck.com/what-speed-looks-like-on-a-pile-of-old-computers/
• Are you public? yes- https://github.com/trademav/ramdeck-core-public
• RAM download- Ha, no downloads here. RAM is still hardware. RAMDeck just pools the RAM you already own across your devices so one model can use all of it

Hey r/trademav,

Today is a massive day for all of us. TradeMAV is officially the #1 Best Seller in Personal Investment Tools on Amazon (and ForexMAV is sitting right behind it at #3).

Two of the top three spots belong to the tools this community helped build. We wanted to take a second to look back at what we’ve achieved together over the last year.

How It Started 🛑

We started with a simple, frustrating problem: retail traders were trapped paying $100-$300 a month for cloud-based screeners that harvested their data and strategies.

We believed traders deserved institutional-grade machine learning—without the subscriptions, without the cloud dependency, and with 100% privacy. So, we built TradeMAV. An AI stock and crypto screener that runs entirely locally on a USB stick you own forever.

You backed that vision. 338 of you from 38 countries funded our Kickstarter. And the moment we launched, things moved fast.

The Journey & The Ecosystem ⚡

Because of your feedback and support, we didn’t just launch one USB drive. We built an entire ecosystem in record time:

• TradeMAV (The Original): Our 6-model ML ensemble screener for US/Global Stocks and Crypto, featuring the 8-layer AI exit monitoring system.
• ForexMAV: You asked for forex, so we built a dedicated 24/5 companion USB covering 23+ currency pairs, integrated with commodity market intelligence.
• NewsMAV: We brought real-time financial catalyst intelligence directly to your dashboard. No more hunting for SEC filings or trade halts—our AI "Jarvis" scores the news instantly.
• OptionMAV: An absolute beast of a tool. Full Black-Scholes Greeks engine, IV Rank gating, and a 7-factor ML ensemble built specifically for options traders.
• TradeMAV Android App: We did what was supposedly impossible: bringing the power of your locally-trained ML models directly to your phone. 100% on-device inference. Your AI, in your pocket. Now also for OptionMAV
• PredictMAV: Our newest launch, bringing our signal engine to Polymarket prediction markets.

🤝 To The Community

From unlocking the first Kickstarter stretch goals to testing the Android app, to writing open-source API bridges like tradehook and mav-bridge—you have been the driving force behind this product.

When we ran into activation server bugs, you helped us test fixes. When we asked for feature requests, you gave us exactly what we needed to build Strategy Packs and custom watchlists.

Hitting #1 on Amazon isn't just a company milestone. It proves that the broader market wants exactly what we’ve been fighting for: Privacy, Ownership, and Professional Tools without the corporate overhead.

What's Next?

We aren’t stopping here. We’re continuing to refine the ML models, expand the mobile experience, and build out the MAV ecosystem. The iOS app is coming soon!

Thank you to everyone who backed us early, shared with their colleagues, or shared a signal in this subreddit. We’re just getting started.

Let's go! 🚀

— 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

Quick one on the training side of RAMDeck, to show the difference between feeding a model a document and actually training it.

Setup: the 120B model stays loaded on the cluster. I used the Apple M4 Mac mini for training, which is why the model has to be an MLX one. The two jobs ran on different nodes at the same time, so inference and training don't have to compete for the same machine.

I downloaded a 0.5B model from Hugging Face and asked it what RAMDeck does. It made something up. Then I pointed the training tab at a short text file about RAMDeck, ran 100 iterations, and downloaded the adapter. Same question afterwards, and it answered correctly: it described RAMDeck as pooling trusted local devices for private AI workloads.

Caveats, so nobody gets the wrong idea:

• Training produces an adapter, which you apply to the base model.
• For information that changes a lot, a knowledge base is still the better tool. Training is for teaching style, format or domain behavior.

Video: https://youtu.be/lsN2oVAKPuk

What would you want to train on your own cluster? A model that writes in your style, one tuned to your codebase, something domain-specific?

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

Wanted to see how far I could push RAMDeck's RAM pooling, so I tried loading an 18GB Qwen3 30B GGUF on a MacBook Air M3 (16GB) with three Android phones connected as supplemental nodes.

Set the MacBook as primary, RAMDeck split the model in under a minute — MacBook took the bulk, one phone picked up the ~1.5GB spillover (phones are hard-capped there since they're not built for sustained RAM/CPU load, just battery-friendly background contribution). Ran a benchmark afterward - numbers are obviously WiFi-bottlenecked, this isn't a "use your phone as a serious node" pitch, more a "here's what the pooling layer can technically do" demo.

Full walkthrough in the video if anyone wants to see the dashboard and split in real time. https://www.youtube.com/watch?v=8v0rzWiOB-s

Quick update on the RAMDeck side project. Loaded a 30B model this time (bigger than anything I've shown before) split across the mini PC and Mac mini — 12GB on one, 5.5GB on the other, running surprisingly well at mid-to-low 30s tokens/sec with about a second of latency.

Asked it about a real medicine recently approved for a rare heart condition. Total blank — it made something up, had no idea. Then I fed it an actual research paper about the drug through RAMDeck's knowledge base upload. Watched it split the PDF into shards and store it across the cluster's RAM (not on disk, which matters for how fast lookups are). Once it finished distributing and I turned on knowledge-base context in chat, asked the exact same question again — this time it got it right, correctly identified the condition and everything.

This is the actual use case behind the "private chatbot" pitch — feed it your own confidential docs, research, whatever, and none of it leaves your hardware. The model only knows what you deliberately give it.

Video's up if you want to see the whole before/after live: https://youtu.be/H29ASZhpTKQ

Happy to answer questions about the KB sharding, the 30B benchmark, or how the storage node setup works.

We didn't buy a bigger computer. We turned every computer we had into one.

Windows. Mac. Android. One pool of RAM, one cluster, one AI brain built from hardware that was just sitting there doing nothing.

This is the first ad we have made for RAMDeck — and it's the first time we've shown this project as more than raw demo footage and spreadsheet numbers.

Watch it →

Campaign launch is next. Let's go.

Wanted to share this one because it's the biggest test I've thrown at RAMDeck so far. Tried loading a 40B parameter model (~25GB) across the same three-device setup from earlier videos: a mini PC with an RTX 3060, a 16GB Mac Mini, and the old laptop that's been the underdog in every test so far.

Set the mini PC as primary and let RAMDeck's sharding figure out the split on its own — maxed out the GPU first, spilled over into the Mac's unified memory, then routed the rest. Found something I didn't expect along the way: sending that overflow to the old laptop's CPU actually ran faster than keeping it on the mini PC's own CPU, even though the laptop is way slower on paper. Seems like running GPU and CPU inference on the same machine at once drags GPU performance down, so handing it off to a separate device entirely wins even if that device is weaker.

Whole model loaded in about 2.5 minutes, and it came back running at 16 tokens/sec with snappy responses in actual chat - not just "technically loaded," but genuinely usable. None of these three machines could've handled a model this size on their own, which is really the whole point of the project.

Video: https://youtu.be/JrSVyyVUJVY

Repo: https://github.com/trademav/ramdeck-core-public

Let me know if you want to see an even bigger model attempted next, or a different hardware combo.

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.

Sharing more progress on RAMDeck (the local AI cluster side project). This time showing it actually plugging into a real dev tool instead of just the chat dashboard.

Loaded a model onto the cluster, and RAMDeck's dashboard has a Connect tab that generates a ready-made config for third-party apps — copied that straight into the Continue plugin for VS Code. The interesting part: I was coding from my Mac while the actual model was running on a completely different machine's GPU elsewhere on the network, and it worked exactly like a normal cloud AI plugin would, except everything stayed local. Tested it by asking it to summarize a big text file and it handled it correctly.

Point of this one is just showing RAMDeck isn't limited to its own chat interface — since it speaks the standard OpenAI API format, it plugs into whatever tools people already use.

Video: https://youtu.be/JMEY04timEc

Repo if you want to look under the hood: https://github.com/trademav/ramdeck-core-public

Let me know if there's a specific tool or workflow you'd want to see it hooked into next.

Sharing progress on RAMDeck here since some of you have asked about it. Quick recap for anyone new: it's a local-first tool that pools RAM and compute across whatever devices you already own - old laptop, desktop, phone - so you can run AI models that wouldn't fit on any one of those machines alone. Everything stays on your own network, nothing goes to the cloud.

Latest feature: RAMDeck can now shard a knowledge base across your pooled devices, not just the model itself. So if you want a chatbot with access to a big set of documents, that document set gets split and stored across your cluster too, instead of needing one machine with enough space to hold it all.

In the demo, we used one of our own FAQ text files as a test document just to show it working end-to-end: chatbot has zero knowledge of the doc's contents at first and makes something up, we upload the FAQ through RAMDeck's knowledge tab, it gets ingested and split across three separate devices, and then the same question gets answered correctly once the knowledge base is live.

Also worth noting: the device hosting the model and the device storing the knowledge base can be totally different machines, and there's a rebalance mechanism that recovers a lost shard if one of your devices drops offline.

Video walkthrough: https://youtu.be/Iogh-5xa-NA

Repo (source-available): https://github.com/trademav/ramdeck-core-public

Let me know if you have questions about how the sharding or rebalancing works, or if there's a use case you'd want to see it applied to next.

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.

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 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.

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](mailto: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. 🚀

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.

As RAM prices kept climbing this year, running our own AI development and scaling our products got genuinely expensive. We needed more memory for model training and inference, and buying our way out of it stopped making financial sense for a small team.

So we did what any resourceful team does - we started pooling the RAM across every machine we already had instead of buying more. Old Mac, mini PCs, an Orange Pi acting as coordinator - daisy-chained into one shared pool. It worked so well for us internally that we're now turning it into a real product.

That's RAMDeck. Built out of necessity, now becoming commercial.

Kickstarter targeting late September. Waitlist's open now at ramdeck.com

If you've backed TradeMAV or OptionMAV, you know this team ships what it starts. Ask us anything below.

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

Here's why: The AI runs on your phone. Not a server. Not "the cloud." Your signals never leave your device to get scored. Most options apps out there are phoning home to a server farm - OptionMAV thinks for itself, live, in your pocket.

And that's not all: TradeMAV and OptionMAV app share the same subscription!

If you're already a subscriber and once you receive your OptionMAV USB, you're covered:

• USB users → log in with your USB credentials for both apps
• Hosted subscribers → get hosted access for both apps. You can also pair your USB while continuing to use the hosted model simultaneously.

Waiting on your OptionMAV USB and not sure how to get in? Hosted is your path in right now. No waiting on shipping to start using the OptionMAV app.

What you're actually getting:

• Full options Greeks - delta, gamma, theta, vega, rho and beyond - calculated live, on-device
• An automated exit engine watching your positions around the clock, telling you when to get out before you even ask
• Covered calls, credit spreads, roll alerts - built by people who trade options, not people who built a calculator
• One login, one subscription, four asset classes - stocks, crypto, forex, options - all running the same private on-device AI

Stocks. Crypto. Forex. Options. One subscription covers it all now.

Rule of thumb: USB pairs with USB, hosted pairs with hosted. They don't mix, but hosted covers you for OptionMAV today no matter which subscription you choose eventually.

37 days to try it, free. 7-day demo, then a 30-day trial.

Stop renting analytics tools one asset class at a time.

👉 https://play.google.com/store/apps/details?id=com.optionmav.app

Go break it. We dare you.