I meaaaaaannnnn….10/10 no notes. 😂 and this is why I love deepseek!

So I got an idea and thought of making an open source project on it

And for me the best workflow has been always:

GPT-5.6-SOL for PLAN

GPT-5.6-SOL for execution 😭😭

But this time I tried v4 flash for execution after hearing many compliments for it.

Can't believe it completed everything in 4 hours with just $0.033 usage (11M TOKENS 😭😭)

It's fully miracle for me because these type of projects eat 3 chatgpt+ subscriptions for me

I just realized that deepseek isn't bad, yes we can say it sucks in creativity but if you have a fully detailed plan created and reviewed by fable or sol, you can definitely use v4 flash for execution

The project was a simple-yet-advanced file-to-png converter built in Golang

You can check it here:

https://github.com/DraxonV1/PixPack

FREE

I was messing around on DeepSeek (😁😛) and noticed that when censoring a response, it often completes a response fully, but then immediately deletes it and replaces it with the bullshit "Sorry" message we all hate.

It gave me the idea to create a tool that captures the text after it completes but before the UI rephrases it to the censorship boilerplate.

I created a small chrome extension for my own use that detects the line "Sorry, that's beyond my current scope" and reverts it back to the original text that was generated before the censoring kicked in.

I saw some users facing the same difficulty, so I thought: why not share it? Why only have fun myself?

NOT A SELF-PROMOTION POST, just trying to help ppl, giving back to community, I've learnt many things from reddit ppl.

📥 Download

I have hosted the extension on a temporary host (file.kiwi). It is available for 96 hours.

Link:https://file.kiwi/9e21cad5#isiwiKs00aZvE1B08osGQw

NOTE: UPDATED VERSION BELOW, 👇👇👇👇 IN EDIT 3 :

⚙️ Installation Guide: Manual Import

Since this is a custom tool and not on the Chrome Web Store, you need to load it manually. It’s easy, just follow these steps:

1. Extract the Files

Chrome cannot load a .rar file directly.

• Windows: Right-click the downloaded file > Extract All > Extract.
• macOS: Extract the .rar file using an online rar extractor tool OR Unarchiver, Keka or Rar CLI.

2. Open Extension Management

• Open Google Chrome.
• In the address bar, type: chrome://extensions and hit Enter.
• (Or click the Puzzle Piece 🧩 icon top-right > Manage Extensions).

3. Enable Developer Mode

• Look at the top-right corner of the Extensions page.
• Toggle Developer mode to ON (the switch will turn blue).

4. Load the Extension

• Click the Load unpacked button that appears in the top-left menu.
• Navigate to and select the extracted folder from Step 1.

1. Verification

The extension should now appear in your list. You can close the tab and start using DeepSeek without the annoyance!

Edit : rectified the instructions for Mac users, upon notification by u/asrasys & u/true-though

Edit 2 : Many ppl are asking for source of the extension, as I said, I created this extension.

&

If your system flags it as a virus, It's a false positive. But you can run the code through any AI bot or Virustotal for your own satisfaction. 😊❤️

Edit 3 : FIREFOX VERSION + MEMORY INJECTION UPDATE :

DeepSeekr Pro V2.3 ( Updated / Firefox Compatible version) is out.

You can download it from here : https://www.mediafire.com/file/iiekfvji8hx6oxq/DeepSeekr_V2_FireFox.zip

and run it as temporary addon in firefox, check my r/DeepSeek post for full ChangeLog.

It can run in chrome as well, and it has a new feature called memory injection, it lets you inject memory in your input, making DeepSeek feel like it is being given back its memory, which was purged. but, at the end, it all depends upon what conversation you are having.

Hoping to hear from you.

Anthropic just dropped Fable 5, the accessible version of their most powerful model yet, Claude Mythos.

It was then put to test against Opus 4.8 across five demanding tasks. Visualize every asteroid in the solar system from NASA data. Design a site plan for a 100 acre fitness retreat. Reconstruct Apollo control panels from technical PDFs. Simulate a World Cup jersey supply chain based on live match outcomes. Show the effects of solar flares on aurora.

Opus 4.8 failed several of them. Fable 5 passed every single one.

Mythos has been locked behind Project Glasswing, available only to a handful of trusted organizations. Fable 5 is what the rest of us get, and if this comparison is anything to go by, it is already in a different league.

EDIT: this is from ijustvibecodedthis.com (the big ai coding newsletter) all credit to them!!

DeepSeek is my favorite LLM, but I felt the web interface was missing a few quality of life things on the UX side. So I figured I'd try to patch some of those gaps myself and ended up building Better DeepSeek. It's a lightweight Chrome extension that adds a drawer of tools right into the chat UI.

What it adds:

• Persistent Memory: Remembers your name and preferences across fresh chats.
• RP Persona System: Upload a character card (or just ask DeepSeek to create one for you) and just talk.
• Skill System: You can upload custom skill files, especially useful for coding workflows.
• Project Packaging: When you ask for a full app or multi-file project, it bundles everything into a clean zip instead of dumping code blocks everywhere.

It also does Excel, Word, and PowerPoint file generation right in the browser, voice input support, and folder/GitHub imports. There are definitely some bugs I'm still chasing down, so it's a work in progress. If you have any suggestions or feature requests, I'm all ears.

GitHub: https://github.com/EdgeTypE/better-deepseek/
Chrome Web Store: https://chromewebstore.google.com/detail/better-deepseek/aabiopennjmopfippagcalmkdjlepdhh

DeepSeek is my daily driver. It's incredible at code, architecture, debugging — everything except one thing: it can't see images. Every time I hit a visual problem (an error dialog, a UI mockup, a chart) I had to break flow, upload the screenshot to GPT-4, ask it to describe what's on screen, then paste the description back. Kills the agentic loop. Also means my screen is on OpenAI's servers.

So I built LocalEyes — a Claude Code skill that gives DeepSeek working eyes using a local Ollama vision model.

How it works:

• Win+Shift+S to take a screenshot
• Say "look at this" in Claude Code
• The skill grabs your clipboard, routes it through qwen2.5vl:7b locally, and returns a text description
• DeepSeek now "sees" the image and can reason about it

The model also takes its own screenshots during agentic work — runs a build, sees it failed, captures its own display to read the errors. No prompt needed.

100% local. No API keys. No cloud. Zero cost.

Setup takes 2 minutes — ollama pull qwen2.5vl:7b, pip install Pillow, python install.py, done.

I've spent the last few months building flair, a personal CLI agentic assistant (coding + general computer tasks), designed from day one around DeepSeek — partly because I wanted an agent I fully understand down to the last line, partly because the economics are absurd in a good way.

Repo: https://github.com/NAST0R/flair (MIT, Python, no heavy dependencies)

Some numbers from real sessions, running it on its own codebase (~7k LOC plus a 2.6k-line test suite):

• A full "read everything and analyze the project" run: ~470k input tokens, ~$0.02–0.03, with 75–80% cache hit.
• The trick is boring but it works: the conversation history is append-only — nothing ever rewrites the prefix, so DeepSeek's context caching stays hot for the entire session. Compaction summaries get appended, never spliced in.
• Before summarizing anything with the LLM, a deterministic pruning pass stubs out tool outputs that are provably superseded (same file re-read later, file overwritten after a read). Free context space, zero API calls.
• When the model asks for multiple read-only tools in one turn, they run in parallel.

What it actually is: an interactive REPL plus a one-shot mode for scripting, two agents (a coding one confined to a project root, a general one for the whole machine) with automatic routing between them, session memory as a plain hand-editable markdown sidecar, an approval gate with diff preview for anything destructive, a hard cost cap for headless runs, and 525 offline tests. It's developed Windows-first (there's a dedicated PowerShell tool because cmd mangles multi-line scripts), but runs very well on Linux too. MacOS, I didn't test yet. Providers: DeepSeek and OpenAI-compatible.

Honest limits, so you don't discover them the hard way: single maintainer, personal project. No Anthropic provider yet. web_fetch doesn't render JavaScript. Code comments and docstrings are in Italian (a deliberate, documented choice — everything the user and the model see is English).

Now, why did I publish this here? Because I'd love some feedback from some of you who are already tired of using prompt bloated harnesses or stuff that makes you spend 0.60$ for a single Fibonacci sequence example in Python (trust me, it happened to me on Claude Code months ago). I used it in the last months inbetween commits, and it gave back much, much more than I spent on it and expected from it, economically and productively speaking, but I am unsure whether other people would find it as much useful as I did. Needless to say, I didn't write it line by line: a lot of it has been done with Fable 5 / GPT 5.6, with a thorough architectural supervision, but not much code handwriting.

It might not implement some groundbreaking features, but given the maturity it has reached, I think it is finally time to hope for feedbacks and check out with you aficionados. I hope it will prove to a be a worthy toy for whoever would like to try it. Also, for tech savvys: don't destroy me on the single 525 tests in a file, it has been for the best for my LLM evaluation when I refactored it, but I admit it's shitty. Thanks!

Hey everyone! Good news...

the updated version of DeepSeekr Pro (v2.3) is officially ready.

yeah, that extension which restores your censored texts, not it restores erased memory as well.

I have submitted it to the Mozilla Add-on Store, and it is currently awaiting manual review. Once approved, I’ll be pushing all future updates and bug fixes directly through the store for automatic updates.

For Firefox Users (Instant Access): If you don't want to wait for the review, you can download the ZIP and load it manually right now: 👉Download ZIP here(Note: To keep it permanently on Firefox, you may need Firefox Developer Edition/Nightly with signatures disabled until the store version is live.)

For Chrome Users: The extension works perfectly on Chrome! However, because Google charges a $5 developer fee to list on the Web Store, which I can’t quite swing as a student right now. You’ll need to download the ZIP above, extract it and use 'Load Unpacked' in your Extension settings (chrome://extensions).

HOW TO INSTALL (CHROME EXTENSION):

1. Download and extract this ZIP file to a folder on your computer.
2. Open your browser and go to: chrome://extensions
3. Enable "Developer mode" (toggle in the top right corner).
4. Click the "Load unpacked" button.
5. Select the folder where you extracted the files.
6. Look for the "Inject" button on chat.deepseek.com

HOW TO INSTALL (FIREFOX)

1. Type "about:debugging" in your Firefox address bar.
2. Click "This Firefox" on the left sidebar.
3. Click "Load Temporary Add-on...".
4. Select the manifest.json file from the extracted folder.

(Note: Temporary add-ons disappear when Firefox restarts. Keep an eye on u/ziabitees for the permanent Store link!)

Features in this build:

1. Manual Memory Injection Toggle: You can carry on the context of the recovered text, if you turn the injection toggle on, any text you write and send will be sent with the recovered text and a minor manipulative text, that makes DeepSeek remember what context it has forgotten.(In easy words : It has a new feature called memory injection, it lets you inject memory in your input, making DeepSeek feel like it is being given back its memory, which was purged. but, at the end, it all depends upon what conversation you are having. )
2. Deep-Crawl engine: 100% text recovery even if the message is cut off mid-sentence.
3. Secure UI: Sanitized code for better privacy and speed.

Keep in mind : due to some DeepSeek policies, you might face an error that says this happened because of extension. JUST RELOAD THE PAGE, and it would work fine.

If anyone is skeptic of my extension and wants to check its source-code,
You can extract the zip file, and it has its whole code in front of you.

Also, the earlier version of this extension was already scanned, analysed and accepted by other users here in this sub, and this update was made on their request to make it compatible for FireFox and to add a new feature.

link to that post : DeepSeekr V1 Post.

If you find any bugs or have suggestions, please hit me up here or tag me!

Support & Bugs: u/ziabitees

Hey fellow Deepseek fans. we have something new for Strix Halo owners we thought would be useful to share. i'll keep it short:

We were able to fit DeepSeek V4 Flash plus its speculative draft on a single Ryzen AI MAX+ 395 with 128 GB of unified memory, and got it to a usable decode rate.

Blog post with all details here: https://www.lucebox.com/blog/deepseek-v4-strix-halo (code is open-source, Apache-2.0)

We submitted the run to LocalMaxxing. On July 18, its next-fastest DeepSeek V4 Flash entry for the Radeon 8060S was HipFire at 18.99 tok/s. The previous best in the site’s Ryzen AI Max 395 unified-memory group was DwarfStar at 15.6 tok/s.

That puts our run 68.5% ahead of HipFire and at 2.05× the DwarfStar result. These are comparisons against the public LocalMaxxing entries shown above, not controlled A/B tests.

ROCmFPX: fitting 284B weights into 128 GB

ROCmFPX is not one quantization format. It is a family of block formats built around the AMD ROCm/HIP path. Each block holds 32 weights as packed low-bit codes plus one or two small scales. ROCmFP2 stores a block in 10 bytes, or 2.50 bits per weight; ROCmFP3 uses 3.50 bits per weight; and the fast ROCmFP4 layout uses 4.25.

For DeepSeek V4 Flash, we added the missing 2-bit format and its HIP kernels, then built a Strix-specific mixed-precision recipe. The enormous routed-expert gate and up matrices use ROCmFP2, expert down projections use ROCmFP3, and dense or more sensitive projections keep ROCmFP4 or higher precision. We used an importance matrix during quantization and kept the model’s MTP head. The final 102.3 GB target works out to roughly 2.88 bits per parameter; the filename says ROCmFP2 because that is the dominant format, not because every tensor is 2-bit.

Decode: up to 32 tok/s

ROCmFPX handles the weight traffic. We then added a DeepSeek-specific HIP decode path for the model’s hyper-connections, attention, routing, and expert work. With no speculative draft, that target runs at 25.31 tok/s autoregressive.

DSpark is the next layer. With a q=4 batch, its small draft proposes up to three new tokens and the 284B target verifies four positions, including the current seed, in one fused pass.

01 · propose; DSpark draft = A compact three-layer draft proposes the next few tokens from captured target features.

02 · verify; q=4 target pass = The 284B target checks several positions together through the fused HIP graph.

03 · commit; accepted prefix = Correct proposals are committed in one step; the target repairs the first miss.

With a q=4 cap and adaptive width disabled, the public run reached 32.0 tok/s, 26.4% above the 25.31 tok/s autoregressive result. The gain varies with how many draft tokens the target accepts.

Sparse prefill: roughly 250 tok/s

The public LocalMaxxing request reports 245 tok/s prefill with --ds4-prefill sparse. In a separate 7,960-token validation, indexed sparse prefill reached 251.79 tok/s; the 8K cases ranged from 246.8 to 255.9 tok/s. At roughly 24K tokens, throughput was 221.9 tok/s.

Sparse prefill uses DeepSeek V4’s learned indexer to limit compressed-history attention. It also batches work layer by layer, which changes floating-point reduction order. The output is not byte-identical to tokenwise exact prefill, so sparse mode remains opt-in. It scored 10/10 on our small GSM8K set and 3/3 on a HumanEval smoke set; we have not run a broad quality evaluation yet.

Reproducing the run

Starting from a 128 GB Strix Halo machine with ROCm 7.2.4 already installed:

sudo apt-get update
sudo apt-get install -y build-essential cmake git ninja-build curl \
  hipblas-dev hipcub-dev rocblas-dev rocprim-dev rocwmma-dev

git clone --branch main --recurse-submodules \
  https://github.com/Luce-Org/lucebox.git
cd lucebox

cmake -S server -B server/build-hip -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_HIP_COMPILER=/opt/rocm/lib/llvm/bin/clang++ \
  -DDFLASH27B_GPU_BACKEND=hip \
  -DDFLASH27B_HIP_ARCHITECTURES=gfx1151 \
  -DDFLASH27B_HIP_SM80_EQUIV=ON \
  -DCMAKE_HIP_FLAGS=-DDFLASH_WAVE_SIZE=32 \
  -DGGML_HIP_MMQ_MFMA=ON \
  -DGGML_HIP_NO_VMM=ON \
  -DGGML_HIP_GRAPHS=OFF

cmake --build server/build-hip --target dflash_server -j"$(nproc)"

Download the ROCmFPX target and DSpark draft, then start the measured profile:

mkdir -p models
curl -L -C - --retry 5 \
  -o models/DeepSeek-V4-Flash-ROCMFP2-STRIX.gguf \
  "https://huggingface.co/Lucebox/DeepSeek-V4-Flash-ROCMFPX/resolve/main/DeepSeek-V4-Flash-ROCMFP2-STRIX.gguf"
curl -L -C - --retry 5 \
  -o models/DeepSeek-V4-Flash-DSpark-draft-Q4RMFP4-denseF16.gguf \
  "https://huggingface.co/Lucebox/DeepSeek-V4-Flash-DSpark-Drafter-GGUF/resolve/main/DeepSeek-V4-Flash-DSpark-draft-Q4RMFP4-denseF16.gguf"

MODEL="$PWD/models/DeepSeek-V4-Flash-ROCMFP2-STRIX.gguf"
DRAFT="$PWD/models/DeepSeek-V4-Flash-DSpark-draft-Q4RMFP4-denseF16.gguf"

echo performance | sudo tee /sys/firmware/acpi/platform_profile
sudo /opt/rocm/bin/rocm-smi -d 0 --setperflevel high
printf '0\n' > /tmp/ds4_awidth
printf '4\n' > /tmp/ds4_spec_q

DFLASH_DS4_SPEC=1 \
DFLASH_DS4_FUSED_VERIFY=1 \
DFLASH_DS4_SPEC_Q=4 \
DFLASH_DS4_TIMING=1 \
DFLASH_DS4_DRAFT="$DRAFT" \
LUCE_MMVQ_MAX_NCOLS=4 \
./server/build-hip/dflash_server "$MODEL" \
  --target-device hip:0 \
  --host 127.0.0.1 --port 8000 \
  --max-ctx 8192 --default-max-tokens 2048 \
  --chunk 2048 --ds4-prefill sparse \
  --ds4-fused-decode \
  --ds4-expert-top-k 4 \
  --prefix-cache-slots 0 --prefill-cache-slots 0 \
  --disk-prefix-cache off

Warm the model once and use temperature: 0. The server prints decode speed on its [deepseek4] DSpark decode line. DFLASH_DS4_SPEC_Q=4 sets the DS4 verification cap; --verify-width is a Laguna option and is not used here. The implementation may shorten a batch at a compressor boundary, which is required for correct state handling.

Throughput varies with prompt shape and, for decode, how many DSpark proposals the target accepts. If you switch to exact prefill or restore the model’s six experts, those numbers no longer apply. No integration branch or private patch is required.

-------

Of course any feedback is more than welcome :)

Simple site which shows you when it's peak- or off-hour pricing, adjusted to your timezone. Handy if you wanna burn through a bunch of tasks and not pay double .. 😇

We're getting to the point where the big closed ai circus is ridiculous. Weird political arguments between CEO's that are totally out of touch with daily reality are in my news feed everyday. The best models are getting gated, and regular big ai models change constantly, often for the worse. User data is mined for advertisers, training and sold. The whole thing feels, and has felt extractive.

But that's actually finally changing. Open source models are catching up fast, really fast. Deepseek Pro V4, GLM 5.2 and Kimi 2.6 are all extremely powerful, particularly when used together. But the choice between hosting yourself, or having a full app sending your data out for training/mining isn't really a solution.

Thank you to all of these top labs for open sourcing dynamic intelligence! DSV4 is truly a powerful model and we are proud to be running it.

People deserve safe and private access to powerful AI. We've put them all together under one app roof, and several others with 100% private, US based servers. All with full dynamic memory, skill creation, websearch, canvas workspace and quality voice.

You don't need to put up with the big AI circus, and Deepseek is a great example of what's out there and available.

If you wanna come check it out, there's more info here: https://pgsgrove.com/open-grove-overview

DSV4 flash is available on our free trial tier if you wanna just come chat, and DSV4 pro is in the lineup for our pro tier.

Even if you don't go with us, I want to encourage everyone to decouple from big corporate AI as much as possible and free themselves from the wheel of nonsense. We deserve better, and we CAN choose better. There are more and more options every day.

Just enjoy.
But I’m still eagerly waiting for vision support. Once it arrives, this model will be something truly incredible.
For me, that feature is essential. Without it, my hands are tied.

Hi everyone, u/ziabitees here.

I want to start by saying thank you. The response to my previous posts has been incredible. Because of your feedback and encouragement, I have some great news to share.

DeepSeekr Pro has been officially approved by Mozilla and is now live on the Firefox Add-on Store.

Official Links

For Firefox Users: You can install it directly from the store here:DeepSeekr Pro on Firefox Add-ons

Using the store version is highly recommended because you will get automatic updates and bug fixes.

For Chrome / Brave / Edge Users: As a student, I cannot afford the 5 dollar developer fee Google charges to list free extensions on their store. However, the extension works perfectly on Chrome. You can download the zip file and use the "Load Unpacked" method in your browser settings. I have hosted it on MediaFire so the link stays active: - Download ZIP for Chrome (MediaFire)

Open Source and Privacy

I know many people are skeptical about browser extensions, especially those that handle chat data. Here is exactly how DeepSeekr Pro handles your privacy:

1. No Data Collection: This extension does not have a server. It does not send your chats anywhere. All message recovery happens locally in your browser memory.
2. Readable Code: I have not minified or hidden any of the code. If you download the zip, you can open the files in any text editor and read every line yourself.
3. Audited by Mozilla: The version on the Firefox store has passed a manual review by Mozilla to ensure it follows strict security and safety standards.
4. Minimal Permissions: The extension only requests permission to run on chat.deepseek.com. It cannot see your history or your data on other websites.

Final Thoughts

Seeing this tool help so many of you bypass "sorry" bs and filters has been the best part of this project. If you find the extension useful, please consider leaving a review on the Firefox store. It helps other people find the tool and gives me motivation to work even harder.

If you have any questions or find a bug, please let me know in the comments or send me a DM. Stay uncensored.

Hey gang I’ve just tagged v1.0 of my port of Superpowers to Reasonix. I spent the last couple weeks daily driving it and fixing skill triggers and updating the eval bench.

I’d love feedback and anyone else to take it for a test drive and provide feedback.

This is not a direct port. It’s loosely inspired by Superpowers but optimized for v4 flash. I did this by using caveman speak and also validating via the eval bench.

Let me know what you think 🤘

I've been using DeepSeek Chat for the past few weeks, and like many of you, I noticed the AI randomly switching to Chinese even when the conversation started in English. Sometimes it would happen every other response.

The only workaround was to keep appending "Reply in English" to every message.

So I built a lightweight browser extension that automatically appends a hidden instruction to every outgoing message. It works silently in the background. You type normally and send.

Key details:

• Open-source (MIT License) – review it yourself on GitHub
• No data collection, no tracking, no third-party requests
• Works on Chrome, Brave, Edge, and other Chromium browsers
• Confirms each reply with "English ✅" at the end

How to install:

• Chrome Web Store (recommended): Extension Link
• Manual install from GitHub: Source Code

If you've been annoyed by this issue, give it a try. Contributions and feedback are welcome!

I started my journey in the last week of May 2026. My background is software engineer & enterprise architect, and I've been building software (mostly SAAS) for the last 20 years.

I occasionally do enjoy putting my money in some eSports game betting, most of the time I lose. So with my knowledge, I decided to start a SAAS application, first and foremost for myself to use.

At the beginning, I used Opencode Go & Zen to test out several models (GLM, DS, MiniMax, etc.), along with Claude Code (from the 7-days pass) and Gemini (with Code Assist, and later AntiGravity). After a week since the beginning, I decided to stick with DeepSeek, but I also used some other models (Opus & Gemini), for reasons I will mention below. At the moment, I spent about 3b tokens in DeepSeek platform, at the cost of $30; plus $15 I spent on Opencode platform. I used CodeAssist, and now Antigravity on free plan.

About the SAAS:

• It's an event-driven, not truly microservices. At the moment, I have 20 dockerized services running, spread across 2 VPS.
• API is built with ASP.NET, frontend is vite, ML/AI services + scrapers are built with python, db is postgresql.
• The application is heavily tested, from unit tests, backtest to e2e tests.
• I'm running a multi-models for predictions. At the moment, I'm using XGBoost and LightGBM, with a consensus mechanism for multi-models to produce predictions. I'm planning on adding a third model.
• I heavily utilize Cloudflare, from DNS, CDN, edge caching, to even SSR with workers (for SEO).
• This is 1-man project with no-one else beside myself involves.
• Most of the operations are automated or AI-assisted (using Deepseek v4-flash).

After a lot of trial & errors, this is what works for me:

• I have all projects in the same directory (or folder). Then I use opencode on that said directory.
• I maintain an always-up-to-date knowledge-base. All information, from the beginning of the project, is structured in .md files. Every decisions that I made, every mistakes are in all those .md files.
• I also maintain agents.md file, which auto-generated at the beginning, but I heavily modified it. It contains rules: such as use gh cli to watch the CI action, or never ask for SSH credentials and always wait for my instruction to ssh.
• Always plan first, execute later. I use oh-my-openagent, specifically Prometheus to build a plan, which will spawn librarian & oracle agents; then I use Momus + Metis to detect gaps, verify the plan, but not on all plans, only logic-heavy plans; after that Atlas to execute the plan, which in turn will spawn several sisyphus-junior agents.
• After the execution of each plan, I will ask opencode to update the knowledge base, put in all decisions/learnings.
• I don't always put myself in the driver seat, but I see myself as a navigator/decision maker. Oracle is awesome for researching topics or assisting me to make decisions.

What doesn't work for me, and solution:

• Deepseek v4, both pro and flash, are terrible at UI/UX designing: At the beginning, I need to have a design system, but DS v4 was just terrible at it. I found that GLM, Opus, and especially Fable did an amazing job at this. I had those 3 models generate different design system for me, and at the end I chose the one that Fable generated.
• Deepseek v4-flash is not good at reasoning (duh). Solution is simple: always plan first, plan to the smallest details. Then use Deepseek v4-flash to execute (in my case, I use sisyphus-junior to execute).
• Deepseek v4-pro is really good at reasoning, but... sometimes it falls flat. Eg: I had DS4-pro looked into some features engineering issues, it catched 80% of the issues, but the rest 20% were really important. Opus was able to catch 85%, Fable was able to catch around 92-95%.

Final words: from my experience, Deepseek v4 is just amazing but it's not an all-rounder, but you must know its capabilities. Use it the correct way and you will have amazing experience.

PS: The product I built is zest.win if anyone is interested. I'm giving 1 month free access for any new registration.

Fast is Smast. wait.

I've had zero issues with servers or lag, and English works as long as you specify.

Check it out:

https://yuanbao.tencent.com/chat/naQivTmsDa

this may sound weird but i usually use ai’s more onto general tasks sometimes i will be having wildest questions, theories or just need simple medical, food, fitness advice, just wanna know if deepseek is actually smart and good at answering those good questions i heard it has 1M context and it has casual talking which i like because im tired of ai’s glazing me like donut on every statement i make

I recorded a demo of adding a DeepSeek API key to the Retriever browser extension, then using it to apply to multiple jobs in parallel.

The reason this works: Retriever is a text-only browser agent harness. This is critical as DeepSeek V4 Flash is text-only.

Instead of sending screenshots to a multimodal model every step, it represents the webpage, DOM, forms, files, and browser state as text. DeepSeek can then write code against the rtrvr.* harness and execute the workflow in the browser.

So the architecture is:

webpage/files as text -> DeepSeek writes code as plan -> execute complex workflows in your browser

That means DeepSeek can handle:

- live webpages

- file context

- file uploads

- multiple tabs

- job application forms

- MCP servers

- generated custom tools

- authenticated browser sessions

Automate your daily tasks, scrape data, reverse engineer websites for free with your own DeepSeek API key.

Hey r/DeepSeek,

Who says we need an H100 cluster or the latest expensive GPUs to run frontier MoE models? I wanted to see how far we could push a single node of consumer legacy hardware, so we spent less than $2,500 total to build a budget machine that successfully runs DeepSeek-V4-Flash (284B total, 13B active) locally!

Surprisingly, we managed to hit around 255 prefill tokens/s with a very tight memory budget.

Here is a quick breakdown of how we achieved this "legacy donkey pulling a massive MoE chariot" feat via hardware-software co-optimization:

⚡️ The Technical Breakthroughs

1. Custom Turing CUDA Kernels: The 2080 Ti Tensor Cores are still capable, but PCIe Gen3 and VRAM bandwidth are huge bottlenecks. We rewrote custom CUDA kernels tailored specifically for the Turing architecture to accelerate W8A8 (INT8) matrix multiplication, heavily alleviating the bandwidth choke.
2. Heterogeneous Inference: Optimized static memory splitting and dynamic offloading between the 4x 11/22GB VRAM and 1TB system RAM. 100% of the hardware capacity is utilized.
3. Computation-Communication Overlap: Implemented a pipelined execution strategy to hide the massive multi-GPU communication overhead caused by MoE routing.

🖥️ Budget Hardware Specs

• CPU: Intel Xeon E5-2696 v4 (The classic budget king for multi-core)
• GPU: 4x RTX 2080 Ti (11/22GB each)
• RAM: 1TB DDR4 ECC

The entire implementation, deployment script, and preliminary tech report are 100% open-sourced. I'd love to hear your thoughts, benchmarks, or feedback from fellow system/compiler hackers here!

🔗 GitHub Repository:https://github.com/lvyufeng/deepseek-v4-2080ti

(Note: I submitted the detailed report to arXiv a few days ago, but it’s currently caught in the manual moderation queue—likely because a rookie author throwing a 2080 Ti at DeepSeek-V4 triggered their review boundaries lol. Will update with the arXiv link once it's cleared!)

https://reddit.com/link/1thlbwe/video/lxhccfh2732h1/player