Run AtomicChat’s IQ2_XXS backbone with ISTA’s separate Engram table through Strata on Windows, Apple Silicon Mac, Linux or RunPod. Includes separate copyable commands, hardware guidance, browser verification and local/cloud API connections for tools.
Capacity guidance is separate from measured speed. Stock 12 GB GPU runs demonstrate offload; they do not establish AtomicChat throughput. Check allocated RAM and free NVMe before downloading.
| Machine | AtomicChat IQ2_XXS + ISTA Engram |
|---|---|
| NVIDIA · 12 GB VRAM / 64 GB RAM | Low-memory candidate based on stock runs; Atomic performance unverified. Fast NVMe required. |
| NVIDIA RTX 4090 · 24 GB VRAM / 128–256 GB RAM | Practical test target with more memory headroom; speed and stability require measurement. |
| Apple Silicon Mac · 128 GB unified memory | Native Metal capacity candidate with SSD streaming. Stock Mac measurements do not establish AtomicChat speed. |
| AMD Radeon · 32 GB VRAM / 251 GB RAM | Stock R9700 result published; AMD custom-file setup not covered. Use NVIDIA route here. |
| Intel GPU · 16 GB VRAM / 64 GB RAM | No supported Intel route in this guide; use the Linux NVIDIA server. |
| Apple Silicon · 64 GB unified memory | Apple Silicon/macOS 15+: native Metal route. 64 GB stock-engine floor; 128 GB recommended; Atomic speed unverified. |
| CPU only · 64 GB RAM | No supported CPU-only serving route here; use a supported NVIDIA GPU server. |
Raw model files total 248.83 GB (231.75 GiB). A stock package with an ~8 GB drafter totals ~257 GB. 300 GB+ free is practical package headroom; preparation or duplicate raw files may require more. For a custom import retaining raw files, budget 600 GB free conservatively until the launch plan confirms whether preparation reuses or duplicates them.
Start small to verify inference before increasing context. The output allowance is part of the context budget. More context consumes memory and can reduce cache space.
| Machine | AtomicChat IQ2_XXS + ISTA Engram |
|---|---|
| Linux / RunPod · 64 GB+ RAM | 8,192 tokens, text only; API smoke test max_tokens 256. |
| RTX 4090 · 24 GB VRAM / 128–256 GB RAM | Start at 8,192; increase only after measuring memory and first-token latency. |
| Apple Silicon Mac · 64 GB+ unified memory | Start at 8,192 tokens, text only. More context consumes unified memory; retain headroom for macOS. |
| Windows NVIDIA · 24 GB VRAM / 64 GB+ RAM | Start at 8,192 tokens, images off; reduce client output allowance if tasks exceed this budget. |
8,192 tokens is a starting test. Leave room for system prompts, tool schemas, files and output. API discovery alone does not prove inference or agent compatibility; measure the exact model on your hardware.
Strata keeps frequently used model data in GPU memory and system RAM, and fetches other data from fast storage. This allows a large model to run on a smaller GPU. Engram is a separate lookup table. Follow the exact custom-file route to load AtomicChat’s edited model.
This setup uses the package documented for this task. Review its source and supported platforms before starting.
Save your machine in My Hardware to get an automatic starting choice. You can always choose any package yourself.
Windows/Linux NVIDIA: 24 GB VRAM and 64 GB+ system RAM recommended here. Apple Silicon: macOS 15+, 64 GB unified memory documented stock-engine floor; 128 GB recommended. Fast NVMe and sufficient free preparation space matter. AtomicChat speed on each machine remains unverified.
Choose where you want to run it. The instructions below update to match your selection.
Untested by YouRunAI. Strata documents local DeepSeek import. We haven’t run this exact AtomicChat package in the desktop app on Windows or Mac.
Download the four AtomicChat IQ2_XXS shards ending in 00001-of-00004.gguf through 00004-of-00004.gguf and the separate ISTA Engram file. Keep all five files in a folder named ds-unc on a fast SSD. Budget about 249 GB for the files plus space for preparation.
In Strata, open Models and choose Use a local GGUF. Select the AtomicChat shard ending in 00001-of-00004.gguf. The built-in DeepSeek download uses the stock weights.
If the app offers these settings, start at 8,192 tokens with images off. Check that the selected file is from your AtomicChat folder, then send a short message in Strata chat and confirm that it replies.
If the app can’t import or start the model, follow the steps below. To reuse your downloads, set the working folder to the parent of ds-unc.
Native Windows 10/11 x64 PowerShell setup with NVIDIA RTX 30/40/50 and driver 580+. No WSL. Run each copy box separately in the same PowerShell window. If you open a new window, repeat the working-folder command. Source-checked instructions; AtomicChat runtime performance is not independently measured.
Open PowerShell on the Windows PC that will run the model. Use a supported NVIDIA RTX GPU with 24 GB VRAM as a practical starting target and 64 GB+ system RAM; 128 GB+ gives headroom. This command uses your user folder. You can replace the path with a folder on another fast NVMe drive before continuing.
Strata Windows requirementsCreate the directory where the four AtomicChat shards and separate Engram file will be downloaded. Continue in this same PowerShell window.
Confirm the intended GPU and driver are listed. CUDA 13 packages require driver 580+. This guide’s native Windows GPU route covers RTX 30/40/50; it does not establish support for every AMD or Intel card.
Read the installed RAM amount. Also open Task Manager → Performance → Memory to check what is available after other apps are running. System RAM is separate from GPU VRAM.
Find the drive containing your chosen folder. Raw model files occupy 248.83 GB before preparation and runtime files. Budget 600 GB free conservatively if keeping raw files in a separate import folder, until the launch plan confirms reuse. A 500 GB total drive can be insufficient.
This downloads the official PowerShell installer. The next copy box executes it. You do not need Git, a source checkout, WSL or a START-HERE.bat file.
Official Windows installationWait for completion. The official installer downloads and verifies the managed runtime, installs for your user and adds its terminal command to your user PATH. Note the path printed at the end.
Run the official Hugging Face PowerShell installer and wait for it to finish. It supplies the hf command used for the exact AtomicChat downloads below.
Hugging Face Windows installerReload the persisted machine and user PATH so commands installed above are available in this window. Alternatively, open a fresh PowerShell window and repeat the first working-folder command before continuing.
Expect a version number. If the command is not found, use the path printed by the Strata installer or reopen PowerShell and repeat the working-folder setting.
Expect the launch help screen. These instructions use the installed Strata Terminal, whose options differ from older source-based setup scripts.
Expect the hf help screen. Resolve an installation or PATH error before starting the large downloads.
This single download command selects all four matching IQ2_XXS shards at the pinned AtomicChat revision. Wait for the download to finish before copying the Engram command. Add --dry-run to inspect the selection first if desired. Rerunning resumes incomplete files.
AtomicChat weights and recipeThis is a separate download from ISTA-DASLab. Keep its original filename beside the four AtomicChat backbone shards. Wait for completion before verifying the files.
ISTA Engram fileExpect four AtomicChat backbone files ending 00001-of-00004 through 00004-of-00004, plus DeepSeek-V4.1-Flash-Engram-IQ4_NL.gguf. Keep them together; the filenames do not include Uncensored.
Check backbone hashes against AtomicChat’s repository. Other quantizations can be reported missing and the separate ISTA file extra in this selected-files directory. Resolve an actual downloaded-file hash mismatch before launch.
Current Hugging Face verification commandCheck the Engram file against its pinned ISTA revision. The AtomicChat backbone files can appear as extras here. Verification reads large files and may take time.
The explicit first-shard path selects AtomicChat rather than the stock built-in model. Keep the separate data directory. Review the selected GPU, custom-file paths, 8K context and text-only/full-quality settings, as well as storage and memory warnings, before launching.
Strata launch flagsRun this one command and wait for preparation and loading to finish. The managed server continues in the background after the command returns. Read the printed server address and log; inspect the custom model path to confirm AtomicChat provenance.
Expect the selected model to be serving. Check the model path and resource settings rather than relying only on a generic model ID.
Inspect failures before proceeding. A completed download or successful installer exit alone does not prove that inference started.
Expect JSON indicating that the model is loaded. Use the actual printed port if you changed the default 8080.
Copy the id under data for the tool’s Model ID field. Use the ID returned by this server, rather than guessing it from the Hugging Face repository name.
Visit http://127.0.0.1:8080 on this PC. Ask for France’s capital, then which country that capital is in. Expect Paris and France. The API section below gives Cline and other tool settings. Tools on this PC use http://127.0.0.1:8080/v1. Keep Strata running until those tools finish.
Keep the model running and choose the route matching where your client runs. A RunPod account API key is not the Strata or gateway key. A reachable /v1/models response verifies connectivity; test generation and tool calling separately.
127.0.0.1 means the computer running the client. A remote RunPod server’s loopback address cannot be used directly from a laptop. Choose one of these routes; OpenAI-compatible clients use a Base URL ending in /v1. Only a client requesting a full Chat Completions URL needs /chat/completions appended.
| Where Strata runs | API Base URL used by the client | Authentication |
|---|---|---|
| Same Windows/Mac/Linux computer | http://127.0.0.1:8080/v1 | Strata key if enabled; otherwise none on private loopback |
| Remote RunPod through an active SSH TCP tunnel | http://127.0.0.1:18080/v1 | SSH connection, plus any configured Strata key |
| RunPod exposed HTTPS port | https://POD_ID-PORT.proxy.runpod.net/v1 | Enabled Strata API key or authenticated reverse-proxy key |
Leave the launch on --access local. Tools on the same Windows PC, Mac or Linux machine use http://127.0.0.1:8080/v1. The command below is for Bash on Mac/Linux; on Windows use the separate PowerShell check and change its port from 18080 to 8080.
On the computer running the tool, use an existing SSH login to the Windows, Mac or Linux model server. The server must already have SSH access enabled and be reachable. Replace model-user@model-server with that login, retaining any required SSH port/key options. Keep the SSH window open and set the tool Base URL to http://127.0.0.1:18080/v1. Strata remains on --access local. On a Mac this uses an existing Remote Login connection; on Windows it needs an existing OpenSSH Server setup.
In RunPod Connect, copy the full SSH-over-TCP/public-IP command with the Pod’s actual port, host and identity-file options. On your own Windows PowerShell, macOS or Linux terminal, add -N -L 18080:127.0.0.1:8080 to that command, then run it. Keep the tunnel open. Use http://127.0.0.1:18080/v1 in your tool. The basic SSH gateway and Jupyter browser URL are not substitutes for this route.
RunPod full SSHRun this on the computer running the tool, while the SSH tunnel is open. Expect JSON with the served model ID. If Strata requires a key, include an Authorization: Bearer header containing that key. A connection failure here should be fixed before changing the tool settings.
Run this in PowerShell on the computer running the tool, while the SSH window remains open. Expect the model list. For a same-machine server, change 18080 to 8080. Authentication requires the configured Strata key if enabled.
Run this privately in PowerShell on the Windows server or Terminal on the Mac/Linux server when a key is configured. Enter that Strata key into the tool’s API Key field. A RunPod account key or Hugging Face token is a different credential and will not authenticate this model server. Do not publish the server key.
Strata access and connection settingsCline is one concrete example. Other OpenAI-compatible clients use the same Base URL, key and served model ID. Compatibility with a chat endpoint does not by itself prove every tool-call format works.
Install VS Code and the official Cline extension on the computer where you want files edited. Open Cline Settings, select OpenAI Compatible and enter the matching address above. Keep the server and any tunnel running. These are settings to enter in the app, not terminal commands.
| Setting | Value |
|---|---|
| API provider | OpenAI Compatible (Chat Completions) |
| Base URL | http://127.0.0.1:8080/v1 for same machine; http://127.0.0.1:18080/v1 through SSH; authenticated HTTPS Base URL for a hosted client |
| API key | Your configured Strata key; a non-secret placeholder only for an unkeyed private loopback route if required by Cline |
| Model ID | Copy the exact id from /v1/models on the reachable server |
| Context window / max output tokens | 8,192 context to match this server; start with 1,024 max output tokens within that budget |
| Images / reasoning / approvals | Images off; reasoning none/low for the first check if available; file and terminal approvals manual |
Open an empty disposable folder in VS Code. Ask Cline: “Create hello.txt containing Hello from Strata. Ask before editing files or running commands. After saving, read it back and report its contents.” Approve only the intended file operation. Confirm the file exists in that folder and that Cline actually invoked its tools. This example checks the client’s tool behavior; it does not claim AtomicChat has already passed it.
On the server, this command prints the OpenCode connection configuration for the running model. Use the printed model/key/context settings in the client. If the client is elsewhere, replace a server-local URL with your tunnel or HTTPS address. This prints configuration; it does not install OpenCode or prove tool calls work. Other adapters are listed by strata connect.
Strata tool adaptersWith the model serving, this separate command sends a prompt and tool call in OpenCode’s format. Inspect both outcomes; a failed check is a real compatibility issue. The check runs from the server and does not verify a remote client’s SSH tunnel or HTTPS path. This 8K DeepSeek setup can be too small for some agents; do not assume 32K connector examples or Hermes’ larger-context defaults fit it.
In a Bash terminal on the server, replace copy-model-id-here with the exact ID obtained above, then run this single request. Expect generated text in choices[0].message.content. For a tunneled client replace 8080 with 18080. For a keyed endpoint, also add -H "Authorization: Bearer YOUR_STRATA_KEY" using your actual key privately. PowerShell users should use their tool’s provider UI or an equivalent Invoke-RestMethod request.
Choose this HTTPS route before the initial launch on a new Pod if your tool cannot use SSH. For a model already running, prefer the existing private SSH-over-TCP tunnel; connecting a laptop does not require another --restart.
Use the SSH-over-TCP instructions above without restarting Strata. An independently authenticated gateway can forward an exposed HTTP port to the loopback listener if one is already configured. A direct RunPod HTTP proxy cannot reach a loopback-only listener on its own.
In the RunPod template, expose the HTTP service port before deploying. Use 8080 only when it is exposed and available; if the template exposes 6080, use 6080 only if another service does not occupy it. The Strata listen port, exposed service port and HTTPS URL port must agree. Editing an existing Pod can erase container-disk files: preserve them first.
RunPod HTTP service portsRun this on the Pod before launch, after checking the template and port availability. Replace 8080 with the exposed free service port, such as 6080, when needed. Keep STRATA_WORK set to the verified model-data folder from the selected RunPod tab.
Use this instead of the local launch on a new Pod. It preserves the selected AtomicChat model path, data directory and inference settings, and changes access, port and key options. There is no need to start local first and force a second restart. Keep public endpoint authentication enabled.
Run this on the Pod after startup and enter that key in your client. If an existing gateway authenticates requests, use its configured key instead. Neither is your RunPod account API key.
Replace POD_ID and PORT with the actual Pod ID and exposed service port. A 401 means the network route is reachable and authentication is required. A 502 generally means RunPod cannot reach a listener on that port. An authenticated request should return JSON listing the served model ID.
Set the tool’s Base URL to https://POD_ID-PORT.proxy.runpod.net/v1 and enter the actual Strata/gateway key locally. Discover the model ID, then test a short /v1/chat/completions request before a large agent prompt. RunPod documents an approximately 100-second HTTP proxy timeout: slow prompts may exceed it, so a direct SSH tunnel is usually better for long generations. Avoid exposing an unauthenticated public Strata endpoint.
These are attributed publisher results. They are not measurements performed by YouRunAI for this workflow.
Strata’s README attributes these stock ISTA 2.00 bpw DeepSeek results to Strata 0.2.5: RTX 5070 12 GB + 64 GB RAM: 4–6 output tokens/s; RTX 3060 12 GB + 46 GB RAM: 9–11; Radeon AI PRO R9700 + 251 GB RAM: 21–25. CPU, NVMe, prompt, context, drafting and expert settings vary. These do not predict uncensored RTX 4090 performance.
Published Strata resultsAtomicChat reports IQ2_XXS at reasoning effort 50 on Strata: GPQA-Diamond 83.3% for stock and edited models; AIME25 76.7% stock and 80.0% edited. AIME25 has only 30 questions; the difference is within noise. These author-reported quality scores are not throughput measurements or evidence of a general improvement.
AtomicChat evaluationRecord model repository revisions, Strata version, exact GPU/CPU, allocated RAM, NVMe, context, expert/drafting settings, prompt/output lengths, cold first-token wait, warm output tokens/s, total time and peak memory. Repeat the same prompt three times after warming. No uncensored-model 4090 throughput or successful Pod run has been independently established here. A successful /v1/models response proves the API is reachable, not that inference or tool calling works. Test a short /v1/chat/completions request first. Large coding-agent system prompts can consume most of an 8K context window. Published throughput for other models or hardware is not a guaranteed benchmark for this community-modified model.
Run this on the model server and include the version with your timing results.
Use this on a supported NVIDIA Windows/Linux host. On a Mac record the Apple chip and unified memory from About This Mac instead; nvidia-smi does not apply to Metal.
Use this command on Linux. On a Mac repeat sysctl -n hw.memsize; on Windows repeat the PowerShell memory check from setup. Do not use free on macOS or Windows.
Use Bash on Mac/Linux with STRATA_WORK set. On Windows, repeat the PowerShell free-drive-space check from setup.
The model must remain running while a client uses its API. A sleeping local machine, closed tunnel or stopped Pod makes the endpoint unavailable.
Run this on the machine serving the model when no client needs it. This stops inference; it keeps the downloaded files for reuse.
In a new shell, repeat your selected route’s working-folder setting first: PowerShell on Windows or Bash on Mac/Linux/RunPod. Rerun that route’s Launch the model command and check status/health. Reopen any SSH tunnel. For the public cloud HTTPS route, use its keyed launch instead.
The launch log identifies the AtomicChat files and separate data directory, health reports loaded, /v1/models returns an ID, and browser/API responses coherently answer Paris followed by France. Record actual latency and memory on your hardware. These are checks for the reader to perform; this source-reviewed guide has not physically run the model.
Documentation and model files checked November 2, 2026. Native Windows NVIDIA, Apple Silicon Mac, Linux NVIDIA and RunPod routes are covered. Copy commands one box at a time in the named shell. All routes select AtomicChat’s files explicitly. Source review does not establish physical execution or tool compatibility on every machine. Keep the configured server key for network/API access.
Run export PATH="$HOME/.local/bin:$PATH" in the current Bash shell, then rerun the version/help checks. Check that each installer completed successfully.
Rerun the pinned Hugging Face download. Keep all four matching AtomicChat backbone shards and the separate Engram file together. Current ISTA main uses a different six-part layout; do not mix its backbone names into the AtomicChat launch or add a llama.cpp shard-six symlink.
AtomicChat intentionally edits tensors while retaining stock filenames and sizes. Current Strata accepts complete user-supplied GGUFs with a stock-hash warning. Verify against AtomicChat’s Hugging Face hashes. Do not bypass verification or substitute stock backbone files. An incomplete/invalid GGUF or mismatch against AtomicChat is an actual error.
Check nvidia-smi and NVIDIA driver 580+ for CUDA 13 packages. Run strata doctor --live and strata update --check. On a rented Pod the host driver belongs to the provider; choose a compatible host if necessary.
Check df -h for both the downloaded files and data directory. Hashing and preparation read hundreds of gigabytes. Inspect the launch plan and logs for extra files and avoid duplicate installs. Stop before downloading when the actual free capacity is insufficient; add storage rather than assuming a nominal 500 GB disk is enough.
Close competing workloads, keep 8K context and text-only settings, and verify the container memory cap. Use fast local NVMe rather than a slow shared/network volume. More RAM can reduce SSD streaming. Compare warm requests separately from startup and cold loading.
Use the full SSH-over-TCP connection and local forwarding. The basic SSH gateway cannot forward ports. Keep Strata on Pod loopback and open local port 18080 through the tunnel. Run /health on the Pod first; then test the tunnel. Jupyter browser authentication is not ordinary API authentication.
Run strata launch --status and inspect the managed server before starting a duplicate. Stop the intended server with strata launch --stop, then relaunch using the explicit AtomicChat path and separate data directory. Confirm logs and /v1/models again.
Confirm the exact model ID, OpenAI-compatible Chat Completions provider, matching 8,192-token context and sufficient output budget. Test a tiny manual-approval file task. Inspect the client and Strata logs; a successful chat alone does not prove tool compatibility. Try the connector’s prompt/tool-call check for that client when available.
Use the Strata key, the model’s HTTP service URL and a Base URL ending /v1. A RunPod account key or Hugging Face token is not the Strata key; the Jupyter URL may return HTML. For the exposed HTTP service, verify Strata is using keyed network access. For SSH, keep the full tunnel open and use local port 18080. Test a short prompt before a large tool request.
Refresh PATH with the command in the Windows route, or open a fresh PowerShell window and repeat its working-folder setting. The default launcher is strata.cmd under Local AppData → Strata → terminal → current → bin. Use the actual full path printed by your installer, especially if you selected another installation folder.
Confirm Apple Silicon and macOS 15+. The documented stock DeepSeek engine starts from 64 GB unified memory; 128 GB is recommended here. Use the internal SSD or fast NVMe, close large memory workloads, keep 8K context and images off, and inspect the actual Metal launch plan. Intel Macs should use the RunPod route. No AtomicChat Mac speed result is promised.
Reattach to the existing tmux session and inspect the cgroup memory cap, mount type and actual free space before restarting work. /workspace can be local or network-backed. Local container disk is ephemeral, so keep persistent copies. mmap experts trade resident memory for disk traffic and can slow generation severely; 64 GB RAM does not guarantee full caching.
Original instructions, model files, and compatibility notes behind this setup.
This small Python demo checks a website’s public HTTP response headers, asks the DeepSeek model running in Strata for three short defensive observations, and saves a styled report. It is a basic security-header review, not a vulnerability scan or penetration test. It uses Python’s standard library; no extra packages are required.
Save the file and open your terminal in that download folder. Use Python 3 and keep Strata running. This is the supplied demo code, available as an ordinary downloadable file.
Download deepseek_security_demo.pyChoose one route below. Replace the example website with a site you are permitted to check. If a local or tunneled Strata server requires a key, supply it privately through STRATA_API_KEY before running; HTTPS prompts for a key when that variable is absent.
Run this on the same Mac or Linux computer as Strata. Replace example.com with a website you are permitted to check.
Open PowerShell in the download folder on the Windows computer running Strata.
Run this on your own computer with the existing SSH-over-TCP tunnel open on local port 18080. The model remains on the Pod.
Replace POD_ID and PORT with your authenticated service address. The script asks privately for the Strata or gateway key; it does not ask for your RunPod account API key.
Set the endpoint in this PowerShell window. For an SSH tunnel, use http://127.0.0.1:18080/v1 instead of the HTTPS example. For HTTPS, replace POD_ID and PORT with your actual service address.
Run the script in the same PowerShell window. HTTPS asks privately for the Strata or gateway key. Use a site you are permitted to check.
The report is written to deepseek-security-audit.html in the current working directory. It opens automatically on macOS; on Windows and Linux, open that HTML file in your browser. The script discovers the served model ID from /v1/models; advanced users can set STRATA_MODEL explicitly.
The header-presence score counts only five checks. It is not an overall website security score, and a missing header does not prove an exploitable vulnerability. Model observations should be reviewed against the actual headers. For very slow generations, prefer the existing SSH tunnel because RunPod’s public HTTP proxy can time out.
Source-backed package and platform-route plan for private local chat with Qwen3.5 · 9B. Preserves the official Ollama 9B package, a smaller 4B family fallback, and a clearly labeled community uncensored GGUF option.
Run Qwen3.8 27B with Ollama, connect it to Cline in VS Code, and make one reviewable code change in a tiny local project.
Generate images from text prompts in ComfyUI with the fast distilled or more adjustable base 4B model. Save your results and reuse the visual workflow.