Home

Field SOP

Scenario-based tutorials with real screenshots, prompts, workflow templates and pitfalls.

ChatGPT Chrome Setup: Six Steps to Minimal Permissions

A hands-on SOP for letting ChatGPT drive your browser, with every step and UI path taken from the official docs at learn.chatgpt.com. Six steps: first, prerequisites (a paid ChatGPT plan, the desktop app, and one of five supported Chromium browsers - Chrome, Edge, Brave, Opera, Vivaldi; Firefox and Safari are not supported); second, installation (desktop app, Settings > Computer Use, pick your browser, Install through the extension store, approve permissions, then confirm the browser shows Manage; on macOS, Computer Use needs Screen Recording and Accessibility permissions); third, invocation (at-mentions like @Chrome, right-click Ask ChatGPT, Cmd+Shift+. on macOS for the side panel, bringing open tabs or selected text into the chat, and the double-Command Appshot); fourth, choosing among three surfaces (tasks needing your existing signed-in profile go to the extension, localhost and preview pages to the built-in @Browser, dedicated integrations to plugins); fifth, permission hygiene with the four-level prompt (Allow once, Allow for this site, Allow for all sites, Decline) plus domain allowlist and blocklist management shared across all five browsers, noting the docs themselves flag Allow for all sites and browser-history access as elevated-risk; sixth, safety habits (treat page content, selected text and video transcripts as untrusted context, review pages before acting, do not leave the agent resident). Known quirks from the official docs: Opera lacks the side chat but supports desktop workflows, only Chromium browsers are supported, and Chrome tasks run grouped in tab groups. Division of labor with the hotspot piece: that one covers OpenAI's product move; this one covers configuring your own machine and keeping permissions minimal.

8GB VRAM, 4K Output: FLUX 3 Klein's Three Pitfalls

A practical path to running FLUX 3 Image Klein on consumer Nvidia cards, with three pitfalls found in the field; every command and filename comes from the official repositories or from third-party recipes that were actually run. The main line is ComfyUI. The repository black-forest-labs/flux-3-image-klein-comfy is gated, marked gated auto in the Hugging Face API, so an anonymous request returns 401 with x-error-code GatedRepo; sign in, accept the terms, then run hf auth login. Next, hf download pulls four files: the distilled int8 transformer at 5,827,874,779 bytes, the Qwen3-VL-4B int8 text encoder at 4,858,559,240 bytes, the w4a8 prompt upsampler at 6,724,090,780 bytes and the FLUX.2 VAE at 336,211,292 bytes. Start with python main.py, open Workflow and then Browse Templates, search FLUX 3 and pick distilled Text to Image with template id image_flux3_klein_distilled_t2i; the template defaults to 1024 by 1024, euler with the simple scheduler, 16 steps and CFG 1, both text-encoder loaders set to type flux3, and the upsampler switch left on. Then the three pitfalls. First, following the card's example and downloading the int8 upsampler at 9,748,113,996 bytes, about 9.08GiB, brings the four files to 19.343GiB, which will not fit a 16GB card, while the ComfyUI v0.41.2 distilled template actually loads the w4a8 file, 2.816GiB smaller. Second, the model card says the editing templates have no upsampler branch and that you should run your own LLM and paste the caption, yet the v0.41.2 editing template does contain an upsampler branch behind a switch that is off by default, a TextGenerate node with the W4A8 loader and an image-editing system prompt, so either route works. Third, running the model without an upsampler gives unstable results in editing and Ref2Image; the card states plainly not to use the model without a prompt upsampler. Memory budget: 11.2GB in BF16, 5.6GB in FP8, INT8 running on 8GB RTX cards, and NVFP4 aimed at data centres. All speed figures are vendor-reported: about 4 seconds per 1MP image on an RTX 5090 and under 9 seconds on an RTX 4070 with the distilled INT8 build, under 0.6 seconds in NVFP4 on a GB300, with a served LoRA adding about 5 percent. Resolution reaches 4K with width and height in multiples of 16, up to 10 reference images are accepted, and official defaults are 16 steps with no guidance for the distilled checkpoint and 50 steps at CFG 3.5 for the base. The Diffusers route is described only as far as is verifiable - it works, and BFL ships reference inference code including a Gradio demo with bounding-box control, with the repository README as the authority; no class names or parameters are invented here. Before commercial use, check the FLUX Kommunity License: free commercial use for individuals and companies under 5 million dollars in annualized revenue, free research and non-commercial use, and self-hosted licensing or the API beyond that, with the LICENSE text governing the details.

Can One GPU Run Matrix-Game 4.0? A Local Deploy SOP

A nine-step SOP for running Matrix-Game 4.0 locally on a single GPU, with every command and flag taken verbatim from the v4 subdirectory README (repository: github.com/SkyworkAI/Matrix-Game, file Matrix-Game-4/README.md). Step 1, align on requirements: model inference needs Linux, an NVIDIA GPU and Python 3.12 together, the reference A100 80 GB deployment uses PyTorch 2.12.0 / CUDA 13.2, and the repo ships a dedicated RTX 5090 runtime that does not auto-detect hardware, so the matching preset must be selected explicitly; the browser demo needs a Linux server that also builds the game and GStreamer pipeline while the Safari/Chrome client needs no GPU; standalone play and recording need macOS or Linux plus CMake, C++20, SDL2 and FFmpeg, with the legacy Windows entry retained but not validated for feature parity; and weights and assets are not shipped in the repo, so budget extra space for the Hugging Face Hub cache. Step 2, install inside the Matrix-Game-4/ subdirectory or everything after is wrong: git clone, cd Matrix-Game/Matrix-Game-4, python3.12 -m venv .venv and source .venv/bin/activate, then pip install torch==2.12.0 torchvision==0.27.0 --index-url https://download.pytorch.org/whl/cu132 as a matched pair, then pip install -e '.[inference,server,download,test]' with all four extras; FlashAttention is optional and only rtx5090-sage needs SageAttention while plain rtx5090 uses PyTorch SDPA. Step 3, downloads come as two manifests, game assets and model weights, pinned to revision 4419accdb7bb7881234c5914de8cd915266e0325 with --scene switchable across castle, racing and all, and one server process supporting only one scene model; the downloader verifies size and SHA256 against the manifests so interrupted runs can simply restart, shared T5/tokenizer and Wan VAE pull automatically from the official base, and matrix-game verify rechecks an installed scene. Step 4, offline rendering proves the model produces output: matrix-game render --scene ancient-egypt --input lowpoly.mp4 --resources resources --preset realtime --prompt-mode fixed --output outputs/egypt, where the input is a low-poly proxy stream rather than real footage and the output is rendered.mp4 plus a configuration report with FPS and frame count preserved; the three presets matter - realtime is for A100, RTX 5090 switches to rtx5090, and quality is slower yet is exactly the default when --preset is omitted. Step 5, play and record locally without loading a model: bash scripts/build_game.sh then bash scripts/play.sh --scene ancient-egypt, giving the two shooter scenes a 48 FPS, 2x simulation-time demo mode with F9 recording and Escape menu, and MATRIX_GAME_DATA_DIR overriding the default data directory; racing uses build_racing.sh with 1x simulation time, and the browser demo does not enable the shooters' 2x mode either, advancing 1/--fps seconds per captured frame. Step 6, the browser demo splits server and client: mediamtx configs/mediamtx.yml in one terminal and CUDA_VISIBLE_DEVICES=0 bash scripts/serve.sh --scene ancient-egypt --resources resources --preset realtime --fps 40 in another, then open http://127.0.0.1:8025/, with --reference-only testing controls, HUD, audio and transport without loading a model; --fps 40 is a capture cadence target, not a throughput or latency guarantee. Step 7, the two RTX 5090 presets: rtx5090 needs no extra installation while rtx5090-sage requires building SageAttention 2.2.0 with the supplied CUDA-graph patch and CUDA 13.2 at git checkout eb615cf6cf4d221338033340ee2de1c37fbdba4a; both reuse the same scene checkpoints and shared resources, converting DiT block linear weights to FP8 at load with activations quantized during inference while embeddings and the output head stay BF16, and startup warms kernels and captures CUDA graphs so the first launch is slower than steady state. Step 8, acceptance in two forms: a keypress producing a picture in the browser demo (officially about under 150 ms, not independently reproduced) or an offline render turning a low-poly video into a finer output, with the three performance accounts written side by side (official 480p 60 FPS, 83 FPS and 18.5 GiB; the project page panel still at 0; and the README's about 38-39 FPS on an A100 at 864 x 480), remembering that model throughput, pipeline throughput, presentation frame rate and end-to-end latency are four different things. Step 9, six pitfalls: one process supports one session and one scene model; it binds to loopback by default and must not be exposed to the internet, since the official statement calls it a trusted single-user demo rather than a public cloud-gaming service; --fps 40 is not a throughput guarantee; Windows is unvalidated; disk must accommodate the Hub cache; and VRAM splits into an A100 80 GB reference tier and an RTX 5090 consumer tier with the 5080 and 5070 still pending.

Run MiniCPM-V 4.7 on Your Phone: Three Paths

A hands-on SOP for running MiniCPM-V 4.7 from phone to desktop in three routes (all figures as of October 15, 2026, official pages prevail). First understand two official numbers: the 3 GB is the model's runtime memory footprint (the MoE-SSD mechanism keeps 35B expert weights on flash and streams them in on demand), not a device-RAM floor - the official app hardware table recommends 12 GB+ RAM for 35B-A3B (validated on the iPhone 17 Pro Max) and 4 GB+ for 1B, with smaller devices falling back to a smaller expert cache that runs noticeably slower; 13+ tokens/s is the official documentation figure for the iPhone 17 Pro Max, and other circulating figures (iPad 15+ and the like) are not adopted. Route 1, the official app on phone/tablet (OpenBMB/MiniCPM-V-Apps covers iOS, Android and HarmonyOS: TestFlight public link on iOS, APK from Releases on Android, signed HAP via DevEco on HarmonyOS; the 35B-A3B phone build is about 16.6 GB - main file plus 40 expert shards plus the vision module; 1B about 1.8 GB; the only fully offline route; pitfalls: slow storage throttles decoding, shards must match or the consistency check refuses to load, and the phone NPU stays unused short-term - the app runs the stock llama.cpp path). Route 2, desktop self-build with llama.cpp-omni for LES acceleration (the official LES link points to OpenBMB/llama.cpp-omni, a fresh repo created October 13 with 16 stars; the community tc-mb same-named repo has 291 stars, full docs and prebuilt packages - both share the same code lineage; verified commands: cmake -B build and cmake --build --target llama-omni-server/llama-omni-cli; GGUF weights in the official quantization repos on HF/ModelScope; honest limits: the README quick start targets the MiniCPM-o 4.5 full-duplex voice pipeline, 4.7 loading details are untested by this site and follow the official README). Route 3, the Ollama shortcut (the official library still lists only 4.6 as of October 15; the OpenBMB publisher page openbmb/minicpm-v4.7 runs today via ollama run - 1b about 1.8 GB, 35b-a3b Q4_K_M about 22 GB and the default latest tag, so small-memory machines must specify :1b explicitly; this route runs whole-model quants with no MoE-SSD, so "3 GB runs 35B" does not apply). One acceptance test for all three: ask about a local image and get a relevant answer. Division of labor with the same-batch open-source piece: that one covers capability and ecosystem, this one only covers getting it running. Repos: github.com/OpenBMB/MiniCPM-V and github.com/OpenBMB/MiniCPM-V-Apps.

AdSense Approval SOP: From Self-Audit to Your First $100 Payout

An end-to-end SOP for applying to Google AdSense as an individual publisher. Hard eligibility (official): 18 or older, a Google account, ownership or authorization for the site, compliance with publisher and content policies, and a valid address plus banking details for payment. There is no official minimum traffic threshold, but thin content is the top rejection reason (community consensus: wait for roughly 50-100 organic daily visitors); the four trust pages (About, Contact, Privacy including cookie and advertising clauses, Disclaimer) matter, especially for finance/health/legal topics. AI-assisted content is not banned - original value and human editing are required, and unedited mass AI production is a common rejection cause. The step chain: sign up (site URL plus payment country) → place verification code (script, meta tag, or Search Console) → wait days to weeks → choose Auto ads or manual units. Payment essentials: file W-8BEN to avoid the 30% US withholding tax, receive funds by wire, account name in all-caps pinyin, +86 numbers can be verified, the payment country cannot be changed after selecting China, and payout starts at $100 monthly. Deploy ads.txt at the site root against unauthorized resale. Our own case: gated pre-placement - the component returns null and renders nothing when NEXT_PUBLIC_ADSENSE_CLIENT is empty (verified live: zero adsbygoogle script loads), ad units use ins.adsbygoogle plus min-height to protect CLS, so pre-placement and activation stay decoupled. Mainland-network reality handled compliantly: applying and the backend need stable access to Google services via overseas network environments, licensed enterprise international private lines, or compliant cloud acceleration; unapproved personal VPN use is illegal in mainland China and this article offers no guidance on it. Chinese ad networks (Baidu/360/Sogou/Guangdiantong/CSJ) all require ICP filing, AdSense does not - a site with filing in progress can prepare both tracks in parallel. After a rejection, fix the cited issues and resubmit. First monetization piece on this site.

Context Compression: How to Stop Agent Context Bloat

A six-step SOP for agent context compression: (1) decide whether you need it (symptoms: long tasks getting slower, pricier and vaguer; a single tool call dumping tens of thousands of raw-log tokens); (2) install context-mode (mksglu/context-mode, 27,378 stars per GitHub API on October 13, 2026, TypeScript, npm package context-mode, wired into your harness via MCP + hooks) and configure thresholds and routing; (3) implement layered compression - offload large tool outputs to disk behind file references, summarize history down to objective/state/constraints/next steps, prune by budget - matching LangChain Deep Agents' three tiers and OPENDEV's five-stage ACC (70% warning / 80% observation masking / 85% pruning / 90% aggressive masking / 99% full compaction); (4) measure with a before-and-after token ledger (per a study cited by agentpatterns: pruning to the last five tool call/response pairs plus summarization reached 91.6% task completion versus 71% for full-context agents); (5) avoid three traps - aggressive summarization causing silent context loss, premature compaction causing objective drift, and summary drift optimizing for brevity over truth (Anthropic recommends starting from maximum recall and converging); (6) know the license boundary: context-mode is Elastic License 2.0 (ELv2, verified from the LICENSE file) - you may not provide it to third parties as a hosted or managed service, personal and internal team use is fine, and wrapping it into a SaaS you sell is explicitly out. README marketing figures (98% tool-output reduction, routing across 17 platforms, HN No. 1 with 570+ points) are vendor-claimed and not independently reproduced. Vendor corroboration (per an October 12 cloudpro piece): OpenAI's Responses API ships compaction (example compact_threshold 200000) and Microsoft Agent Framework offers summarize/remove/collapse strategies. Repo: github.com/mksglu/context-mode (ELv2).

Running 27B on 4GB VRAM: Disk, Not VRAM, Stops You First

A five-step SOP for layer-wise inference with airllm (October 12, 2026; figures are vendor self-reported): (1) respect the triple version lock - torch must be a CUDA 12 build (no prebuilt flash-attn wheel for CUDA 13), plus flash-attn, plus a transformers branch that depends on the model (4.56.x for Kimi K3, 5.8+ for Qwen3.8-27B, an in-tree qwen4_exp build for Flash-Next), verified with both nvidia-smi and torch.cuda.is_available(); (2) pick a tier from the README measurements - the most realistic entry point is Qwen3.8-27B at 3.33GB (RTX 3090); (3) the first run pays for the download (Flash-Next checkpoint around 360GB, K3 in the TB class), finish it once and keep the cache directory, and reclaim pre-split originals with delete_original=True; (4) watch VRAM peaks with nvidia-smi and manage expectations - layer-wise streaming moves far more bytes than it computes, the vendor publishes no tokens-per-second figure so none is invented here, and slow is the design, not a bug; (5) wire it into agent or API workflows: fine for one-shot task-shaped work, wrong for token-by-token interactivity; training takes a different path (frozen weights streamed layer by layer, adapters kept on GPU). Five dedicated trap sections: the version matrix, the hundred-GB-to-TB first download that stalls, the hidden disk and host-RAM gates (64GB-class RAM to start), structurally slow output, and K3's hard flash-attn plus CUDA 12 constraints. Repo: github.com/lyogavin/airllm (Apache-2.0).

TRAE Merged: Stop Using It Like an IDE, Master Agent Mode

A six-step SOP for getting comfortable with TRAE's Agent mode after the upgrade (as of October 11, 2026; pairs with the news piece). The steps: (1) know the two modes - the app now opens into the Agent workspace by default and IDE mode must be selected by hand (official community feedback); (2) run your first Agent task - natural-language requirement breakdown to page scaffolding, testing and docs, with cross-project parallel dispatch; (3) SOLO mode - a dedicated coding agent that advances each phase independently; (4) tool wiring - MCP external tools plus TRAE Rules for your own working rules; (5) the Project Artifacts hub - code/HTML/PPT/Word/images/videos reviewed and iterated in one place, plus automated tasks (weekly reports, routine checks, test roundups); (6) three-device sync - start on desktop, check progress and add requirements from mobile, return to desktop. Four traps: upgrade before TraeWork stops service on October 23, 2026 (Pandaily citing official docs); do not close the upgrade window during data migration; staged rollout means no update prompt yet is normal; mode-switching guidance is weak. Each step carries actions and expected results; features per official announcements, unpublished details not invented.

Mellum2.1 Deploy SOP: Run a 12B Coding Agent on 24GB

A Mellum2.1 local deployment SOP (as of October 10, 2026; pairs with the open-source and comparison pieces). The vLLM main route in five steps: serve JetBrains/Mellum2.1-12B-A2.5B-Thinking, set reasoning-parser qwen3 (official model card; without it thinking text bleeds into answers), basic inference verification, tool calling (optional Hermes template) plus 131K-context validation, then an agent smoke test - each step with its expected result. Three traps first: the MTP head was not released with the weights, so the advertised 1.6x speedup is not reproducible today; GGUF is not out, so "announced" Ollama/LM Studio support is not usable today - distrust integration packs; and this is a thinking model, so a reasoning parser is mandatory. Hardware ledger: BF16 around the 24GB class (estimate; no official number), 16GB cards cannot hold it, 24GB (4090/3090) is the working floor and full-131K context adds KV cache on top. Two high-frequency failure modes get their own paragraphs: OOM dies at weight loading, not mid-generation (--gpu-memory-utilization only throttles KV cache, it cannot fit oversized weights), and first-run downloads of the large checkpoint can look hung - finish it once, keep the HF cache directory, and every later start is local. Dual-run reconciliation pairs with the comparison piece: race Qwen3.5-9B on the same harness for tokens/s and tickets solved; performance conclusions come from your own repo, not vendor charts. Repo: huggingface.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking.

ComfyUI Video Generation SOP: Run LTX-2.5 on 12GB VRAM

A ComfyUI local video generation SOP, using LTX-2.5 to get a 12GB card through the full pipeline. Model files and directories (int8_convrot builds, not BF16): the transformer goes to models/diffusion_models/, gemma4-12b-with-proj to models/text_encoders/, the video and audio VAEs (both bf16) to models/vae/, and the 2x latent upscaler to models/latent_upscale_models/. Pitfalls first: the audio VAE is a separate file - skip it and you render a silent video; the prompt enhancer is an extra ~5GB model adding 1-2 minutes per generation and is off by default; HF gated=auto means you must log in and accept terms to download (even to read the model card). Hardware floor: 12GB VRAM with distilled/int8, CUDA 12.7+, PyTorch ~2.7, Python 3.12+ (innfactory's compilation); on 8GB cards, switch to Wan 2.2 TI2V-5B with offload instead. Three workflow types: two-stage T2V/I2V (generate, then 2x latent upsample refinement), single-stage (fast, for previews), and A2V (audio-driven video). VRAM strategy: quantized/distilled first, ComfyUI native offload, short low-res generation then upscale. Repos: github.com/Lightricks/ComfyUI-LTXVideo, huggingface.co/Lightricks/LTX-2.5.