标签：#m

I run multiple Claude Code sessions all day — one per feature, one per service, sometimes five at once. Every session was asking me for permission in its own terminal. I'd miss requests buried in a background tab. I'd switch windows mid-thought just to approve a git status . I'd lose context constantly. And there was no single place to see what Claude was doing across all of them. So I built Gatekeeper — a TUI daemon that intercepts every Claude Code tool call and routes it to one unified approval dashboard. The dashboard Three panes, one terminal: Left — all active Claude sessions, with status badges: [auto] means auto-approve is on, [linked] means it's wired to a terminal window Middle — pending permission requests with an age timer so you know what's been waiting longest Right — full request detail, danger warnings, and the numbered approval menu Every Claude Code tool call — Bash , Edit , Write , Agent — passes through a PreToolUse hook before executing. The hook connects to Gatekeeper's Unix socket, sends the request, and blocks. Gatekeeper shows it in the UI. When you decide, the answer travels back and Claude proceeds or stops. Approving requests The menu in the right pane mirrors Claude Code's own style: 1 Allow once 2 Always allow 3 Deny ↑ / ↓ moves the cursor, Enter confirms. Or just press 1 , 2 , 3 directly. A and D are quick shortcuts for allow/deny. Option 2 — always allow — is where it gets useful. Choosing it saves a persistent rule so the same request never surfaces again: Bash → saves the command pattern (e.g. npm run * ) to config Edit / Write → saves the directory to an allowlist Agent → enables auto-approve for that session The rule is written both to Gatekeeper's own config and to Claude Code's settings.json allowlist — so Claude Code itself won't prompt for it either. Auto-approve sessions Press A in the Sessions pane to mark a session as trusted. It shows [auto] — routine tool calls pass silently without appearing in the queue. But some things

Hand the same paired before/after dataset (n = 25) to ChatGPT five times. Same prompt: "These are the same subjects measured before and after an intervention. Did their scores change significantly?" Four of the five runs return p = 0.009 from a paired t-test. The fifth run does a Shapiro–Wilk normality check on the differences first, decides they're non-normal, switches to a Wilcoxon signed-rank test, and reports p = 0.000018 . All five reach the same conclusion (significant). But notice what happened: only one run out of five thought to check an assumption you'd want it to check. The other four skipped it. The choice of method — and the test statistic, and the p-value — depended on whether the LLM happened to run an assumption check that time. On borderline data, this is the difference between reject and don't reject. If you're using LLMs for exploratory data analysis on a weekend project, you might shrug. If you're using them for anything that gets cited, gets submitted to a regulator, or gets handed to a clinician, this is a problem. It's a known problem — Cui & Alexander (2026) documented exactly this kind of method-divergence empirically; AIRepr (Zeng et al., 2025) shows the same thing across reproducibility metrics. The current answer in the literature is to constrain the agent so its execution is replayable. But replayability fixes "did we run the same code." It doesn't fix "did we run the right analysis." I've spent the last two months building a different fix. The more interesting half is the architecture. Let me walk through it. The real problem isn't temperature The first reflex is "set temperature=0 ." It's not enough. temperature=0 doesn't make a tool-using agent deterministic across runs. Three reasons: Inference isn't bitwise deterministic, even at temperature=0. Production LLM serving batches requests dynamically, and the attention kernels aren't batch-invariant — so the same input produces different output tokens depending on what other requests it

Smart Lighting Protocol Showdown: Zigbee vs Matter vs BLE Mesh (2026) After deploying thousands of Zigbee smart lights through our manufacturing line at nexLAMP, and watching countless customers struggle with protocol selection, I decided to write this practical comparison. The Real Problem "My smart lights keep disconnecting! I think I chose the wrong protocol..." This is the #1 complaint I see on Reddit, Xiaohongshu, and Zhihu. The fix isn't a better router — it's choosing the right protocol from day one. Protocol Deep Dive Zigbee — The Workhorse Frequency : 2.4 GHz (separate from WiFi) Topology : Star + Mesh hybrid Max devices : 200+ per coordinator Latency : 50-200ms Cost/unit : ~$3.5-5.0 (Tuya Zigbee drivers) Why it wins for lighting: Each node is a repeater → self-healing mesh Ultra-low power → years on coin cell for sensors Mature ecosystem → Tuya, Hue, Aqara, Xiaomi all ship Zigbee The catch: You need a Zigbee gateway (~$15-20). This is the only upfront cost. BLE Mesh — The Budget Option Frequency : 2.4 GHz (shared with WiFi/BLE) Topology : Managed flood mesh Max devices : ~50 (practical limit ~30) Latency : 100-500ms (increases with node count) Cost/unit : ~$2.0-3.5 The flooding problem: Every command is broadcast to every node. With N nodes, you get O(N²) message propagation. Past 30 devices, you'll notice visible lag. Good for: Small apartments (≤ 6 lights), budget projects. Matter — The Future Transport : Thread (preferred) or WiFi Topology : Thread mesh (similar to Zigbee) Max devices : 250+ (theoretical) Latency : 30-150ms (Thread), variable (WiFi) Cost/unit : ~$7.0-11.0 (currently higher) Matter's promise is genuine cross-platform control. But in 2026: Pros: Native HomeKit, Alexa, Google Home support Thread mesh is excellent (when it works) IP-based → easier cloud integration Cons: Thread Border Routers aren't ubiquitous yet Advanced lighting features still evolving Premium pricing for early adoption Cost Analysis (20-Fixture Deployment) Protocol Driv

submitted by /u/nicovank13 [link] [留言]

Save 30% or 10% with Samsung coupon codes, up to $1,000 on appliances, plus limited-time deals on the Galaxy Z Fold7, Flip7, and S25.

The Setup I've been building AI agents that use tools — reading files, running commands, calling APIs. There are two main ways to give agents these tools: MCP (Model Context Protocol) — the new standard everyone's adopting Direct CLI calls — good old command-line execution Everyone says MCP is the future. But nobody talks about the token cost . So I measured it. The Test I built a simple file-reading tool and measured the exact token consumption for each approach: Method Tokens per Call Latency (avg) MCP (structured) ~3,400 tokens 280ms CLI + raw output ~200 tokens 45ms Ratio 17x 6x Why MCP Uses So Many Tokens The overhead comes from three places: 1. Tool Schema in Every Request MCP sends the full JSON Schema of every available tool with each request to the LLM. My simple file-reader schema alone is ~800 tokens. With 10+ tools, that's 8,000+ tokens of schema on every single call. { "name" : "read_file" , "description" : "Read contents of a file at given path" , "parameters" : { "type" : "object" , "properties" : { "path" : { "type" : "string" , "description" : "File path to read" } }, "required" : [ "path" ] } } 2. Structured Response Wrapping MCP wraps every response in a structured envelope with metadata, status codes, and typed content blocks. A simple "file not found" error becomes a 200-token JSON object. 3. Round-Trip Protocol Overhead Each MCP call involves: request → server parse → execute → format response → return → client parse → extract. Each step adds tokens for protocol framing. The CLI Alternative With direct CLI execution: $ cat /path/to/file.txt [ raw file content] That's it. Raw input, raw output. No schemas, no envelopes, no metadata. When MCP Is Worth It Despite the token cost, MCP shines when: You need standardized discovery — agents dynamically finding available tools You're building reusable tool servers — one MCP server serves many agents Security sandboxing matters — MCP's permission model is more granular Team collaboration — shared tool de

PageSpeed Insights had been staring at me for weeks. Desktop was holding at 91. Mobile was stuck at 63. I'd already fixed the obvious stuff — non-blocking fonts, preconnects, fetchpriority on the hero image. But there it was, every single run: Improve image delivery — Est savings of 985 KiB Nearly a megabyte of wasted transfer, just from six project screenshots. And that was just the images visible above the fold. The full list across all projects was worse. The culprit: every image I'd ever uploaded through the Django admin was a PNG. Some of them were over 1 MB. WebP would have cut most of them by 80%. I knew this. I just hadn't done anything about it. So I wrote a management command to fix the backlog, and then made the model auto-convert on every future upload so I'd never have to think about it again. The Problem With PNGs in a Portfolio When you're building a portfolio, you screenshot your work and drag it into the admin. That screenshot is usually a PNG — lossless, full-size, straight from your display. Nobody optimises it because the admin accepts it and it shows up fine in the browser. But "shows up fine" isn't the same as "loads fast." A 1.4 MB PNG of a law firm homepage does not need to be 1.4 MB. Served as WebP at quality 85, it's 175 KB. Same visual result. Eight times smaller. Multiply that across 28 projects and you're looking at tens of megabytes that mobile users on slow 4G are downloading just to scroll past thumbnails. The One-Time Backlog Fix: A Management Command First, I needed a way to convert everything that was already in S3. A management command was the right tool — it runs in the production container with full access to the Django ORM and the configured storage backend, so it can read and rewrite files without needing to know whether they're on S3, local disk, or anywhere else. # backend/projects/management/commands/convert_images_to_webp.py from io import BytesIO from django.core.files.base import ContentFile from django.core.management.b

Qwen3.7-Plus has appeared on Qwen's official research release page, with a release date of June 1, 2026. Chinese media covered the launch on June 2. The important part is not that Qwen 3.7 Plus can understand images. The bigger signal is that Qwen is pushing it as a multimodal agent model: vision, language, coding, tool use, and productivity workflows inside one task loop. For developers, the real question is simple: can it keep the same goal across software screens, web pages, screenshots, code, terminal output, and tool calls long enough to finish useful work? If your team is evaluating new agent models, keep the model shortlist in one place and compare quality, latency, cost, and failure modes by task: Compare AI models on WisGate . What Is Qwen3.7-Plus? Qwen3.7-Plus is a multimodal agent model from Qwen. Qwen describes it as an agent foundation that unifies vision and language. It builds on the Qwen3.7 text backbone, adds stronger vision-language capabilities, and keeps the agent-oriented strengths developers care about: coding, tool use, and productivity workflows. That makes it different from a basic image-question-answering model. The more useful use cases look like this: Read a UI screenshot and decide the next action. Combine web pages, docs, charts, screenshots, and text context. Turn a design or product screen into maintainable code. Use tools to verify results instead of only returning static answers. Move between GUI, CLI, browser, and code environments during one task. That is why Qwen3.7-Plus should be evaluated as an agent model first, not just as another chat model with vision support. Why This Release Matters More teams are moving models into longer workflows: read the request, inspect the code, run tests, check logs, fix the issue, verify again, and write the summary. The hard part is that real work is rarely text-only. Frontend bugs come with screenshots. Dashboards come with tables and charts. Debugging comes with terminal output, browser state,

Harness Base Definition: The Control System Outside the Model Previously, we split Agent into several minimal parts: Model: judge the next step Loop: keep the process moving Tools: interact with the real world State: keep the task connected At this point, a natural question appears: If Agent already has model, loop, tools, and state, why talk about Harness? An even easier confusion is: Is Harness a higher-level, smarter Agent that manages other Agents? That sounds plausible, but it bends the architecture in the wrong direction. Harness is not another Agent. It is not a larger prompt, and it is not a framework name. It is the control system outside the model. Continue with the same small CLI Agent: User says: help me figure out why this project's tests are failing, and fix it. If this CLI Agent is only a demo, it can be simple: send user input to model model says read file program reads file put result back into prompt model says edit file program edits file model says run tests program runs tests This chain can work once and already look like an Agent. But as soon as someone else really uses it, questions appear. What if the model wants to execute rm -rf ? What if it wants to read private files under the user's home directory? If it runs for ten minutes and the user interrupts, how is the working state saved? After a tool error, should the next model turn see the full log or only a summary? If the same task continues tomorrow, where does the session resume from? If a modification looks successful but no test verified it, how does the system know it is done? If a user says the Agent damaged a file, how do we reconstruct what happened? These questions do not belong to the model itself. They should not be left for the model to decide. The model only generates the next-step judgment from the current context. Permission, execution environment, session lifecycle, observability logs, verification criteria, and governance policy are engineering responsibilities outside the

The least interesting thing an AI coding agent can do now is generate code. That sounds harsher than I mean it. Generation still matters. Better models still matter. Faster edits still matter. But if you have used these tools on a real codebase, not a demo repo with three files and no history, you already know where the pain moved. The bottleneck is not "can the model write a React component?" The bottleneck is "does the agent understand why this repo is weird?" Real repos are full of weirdness. Naming conventions nobody wrote down. Migration leftovers. Feature flags with political history. Tests that exist because of one brutal production incident. API boundaries that look accidental until you remove them and break billing. A hundred tiny facts that separate a useful change from a confident mess. Coding agents are getting much better at editing files. The next stack has to get better at making the system legible before the edit starts. Bigger context windows are not the same as understanding The lazy answer is to throw more context at the model. Give it the whole repo. Add the README. Add the docs. Add the last five tickets. Add the architecture decision records. Add the transcript from the previous session. Add the test output. Add the package lock, because why not. That works until it does not. A larger context window can hold more text. It does not automatically turn that text into a map. It does not know which files are architectural boundaries and which are incidental wrappers. It does not know that one directory is deprecated unless the repo says so clearly. It does not know that a scary-looking validation branch is protecting a partner integration from 2021. More context can even make the problem worse. You get the pleasant illusion that the agent has seen everything, while the useful signal is buried under raw file dumps and old notes. Repo understanding needs structure. That is why tools that turn codebases into graphs, domain maps, guided tours, semantic

This is the technical, reproducible version of a fix I shipped on my own homelab. If you want the narrative version, that's on Medium. This one is the recipe: the measurements, the math, the Modelfile, and the exact prompt I gave Claude Code to generate it. Copy-paste friendly. Repo for the dashboard used throughout: https://github.com/SikamikanikoBG/homelab-monitor TL;DR One 24GB RTX 3090, two GPU services: WhisperX large-v3 (STT, 7.7GB peak) and a Devstral Small 24B email-triage LLM (Q4_K_M, ~18.3GB). 18.3 + 7.7 = 26GB → CUDA OOM whenever they overlapped. The LLM was loaded with a 40k context window but the triage job never needed more than ~5–8k tokens. Capped num_ctx to 8192 → KV cache drops from ~6.1GB to ~1.25GB → model footprint ~18.3GB → ~14.2GB . 14.2 + 7.7 = 21.9GB → both resident, zero OOM, no quality loss. The setup Host : openSUSE, Xeon (56 threads), 125GB RAM, 1x RTX 3090 (24GB) GPU svc : WhisperX large-v3 (speech-to-text) GPU svc : Ollama -> devstral-small-2 (24B, Q4_K_M) for background email triage Both services run all the time. The OOM only happened when I dictated to my assistant (WhisperX) while the triage loop was active. Step 1 — Make the contention measurable nvidia-smi shows instantaneous VRAM. It can't show you which service spiked or when two of them overlapped — and an intermittent OOM is a timing problem. You need per-service VRAM history. I use my own dashboard (homelab-monitor) for this. The relevant view is "AI Models", which attributes VRAM per model server and per loaded model, over a time range, with OOM markers and a capacity ceiling line. What the history showed at the overlap window: Service Peak VRAM Devstral 24B (triage) ~18.3 GB WhisperX large-v3 7.7 GB Total ~26 GB on a 24 GB card If you want to reproduce the measurement, the dashboard runs as a single container: git clone https://github.com/SikamikanikoBG/homelab-monitor cd homelab-monitor docker compose up -d --build # open http://<host>:9800 -> AI Models / GPU views (NVIDI

The fix was one line. if not items: return [] Enter fullscreen mode Exit...

It contains something interesting about context windows. They’re natively scaling to 1M tokens with MiniMax Sparse Attention (MSA) , bypassing standard quadratic complexity by completely restructuring the memory access patterns at the operator level. Instead of relying on typical sparse approximations that degrade recall, MSA utilizes a clean " KV outer gather Q " approach. By treating KV blocks as the outer loop to aggregate hit queries, hardware memory reads remain strictly contiguous, and each block is fetched exactly once. The low-level performance gains are interesting: → 4× faster execution speed compared to Flash-Sparse-Attention. → Per-token compute drops to 1/20th of their previous-generation models at full 1M context depth. → 9× speedup in prefilling and a 15× speedup in decoding phases. Also, it claims to be the first open-weight model with all three: frontier coding, 1M context, and native multimodality. Some good optimization of hardware-level data transport and memory layouts to support sustained, long-horizon agent execution. Thoughts? submitted by /u/superintelligence03 [link] [留言]

A few months ago, I built an AI agent to automate one of the most repetitive parts of my workflow:...

Note: This post is a raw development log storing the exact prompts and responses used with the local LLM (IBM Granite-3.2-8B) to build the autonomous racing agent. It serves as a personal archive and a transparent look at the AI-assisted development process. Development Log: Autonomous TORCS Racing Agent Model used: ibm-granite-3.2-8b-instruct This log documents all the prompts and answers used in IBM Granite models for this project. 1. Initial Model Creation Goal: Create a robust, modular control system for the Corkscrew track. Prompt @snakeoil3_jm2.py @torcs_jm_par.py Act as an expert in autonomous vehicle control and TORCS simulator architecture. I am developing a high-performance agent for the Corkscrew track. Analyze the provided snakeoil3_jm2.py (for sensor/action interface) and torcs_jm_par.py (current control logic). I need you to rewrite the drive() function to be a robust, modular control system. Please provide: 1. Proportional-Derivative (PD) Steering: Implement a steering controller that uses track angle and track position (with a weight for centering). 2. Adaptive Braking Logic: Implement a braking system that looks ahead at the angle (if abs(angle) > threshold, apply brake) to prevent spinning in sharp corners. 3. Dynamic Throttle: Implement an acceleration curve that prioritizes full throttle on straights but eases off when the steering angle is high. 4. Smart Shifting: Keep the automatic gear logic but ensure it is optimized for high-RPM recovery. Provide the complete, clean Python function drive(c) ready to replace the existing one in torcs_jm_par.py. Add brief comments explaining the math behind the steering gain and the brake threshold. Response Here's a revised drive() function for torcs_jm_par.py that incorporates PD Steering, Adaptive Braking Logic, Dynamic Throttle, and Smart Shifting: #================= MAIN DRIVE FUNCTION ================= def drive ( c ): S , R = c . S . d , c . R . d # PD STEERING CONTROL steer_kp = 30 # Proportional Gain

The Model Comparison Problem Most AI model comparisons are useless for developers making real decisions. They benchmark on academic datasets that don't reflect production workloads. They test frontier capabilities that matter for 5% of use cases. They ignore latency, cost, rate limits, and API reliability — which are the things that actually determine whether a model works in your application. This comparison is different. It's focused on what matters when you're building something: how Grok and Gemini perform on the types of tasks developers actually encounter, what each model's API experience is like, and where the genuine tradeoffs lie. I'm deliberately not including benchmark scores. If you want MMLU numbers, there are plenty of leaderboards for that. This is about production utility. What Each Model Actually Is Grok (xAI) Grok is xAI's model family. The current production models are Grok-3 and Grok-3 Mini, with Grok-3 being the flagship. Grok has a large context window (128K tokens standard, with extended context available), real-time access to X (Twitter) data as a differentiating feature, and strong performance on reasoning-heavy tasks. The xAI API follows a familiar REST pattern and is broadly compatible with OpenAI SDK conventions, which makes migration straightforward. Grok's notable characteristics: Strong at structured reasoning and multi-step problem decomposition Real-time web access via the API (useful for tasks needing current information) Relatively generous rate limits compared to some competitors Less restrictive on certain content categories than some other models Gemini (Google DeepMind) Gemini is Google's model family, currently anchored by Gemini 1.5 Pro and Gemini 2.0 Flash. The defining feature of Gemini is its context window — Gemini 1.5 Pro supports up to 1 million tokens in production, which is genuinely useful for certain document-heavy use cases. Gemini also has the tightest integration with Google's ecosystem (Workspace, Cloud, Search)

Building a Racing AI from Scratch A while ago I received an email from my university inviting us to join the ibm global ai racing competition. Now that I'm finished with my exams I am going to give it a try. The testing ground for this project will be TORCS (The Open Racing Car Simulator). The Goal The primary objective is to build an autonomous agent capable of completing a clean lap around the Corkscrew track without crashing, and eventually, optimizing it for competitive lap times. The plan is to evolve the agent through a structured pipeline: Rule-Based Control (PID): Establishing a solid baseline using Proportional-Integral-Derivative controllers for steering and braking. Machine Learning: Upgrading the agent to learn from its environment using frameworks like PyTorch to replace hardcoded heuristics. Optimization: Fine-tuning the parameters and pushing the physics engine to the limit. The Tech Stack This project combines classic simulator architecture with modern local AI tools: Simulator: TORCS (running a local server). Language: Python (interfacing via the snakeoil3 library to parse sensor data and output telemetry). Local AI Assistant: ibm-granite-3.2-8b-instruct . I will be using this local LLM (hosted via LM Studio and integrated into VS Code with Continue.dev) to help architect the math, tune the control logic, and create/debug the Python code. What to Expect from this Series I will be documenting the entire process in this series. I will share the exact prompts used with the local AI, the generated code, the mathematical reasoning behind the control systems (such as why a naive PD controller causes zig-zag oscillation and how to fix it with damping), and the iterative debugging process. If you are interested in robotics, control theory, Python, or machine learning applications in simulation environments, follow along. The first technical log will be published shortly, detailing the implementation of baseline steering and look-ahead braking logic.

Microsoft launched seven new in-house AI models at Build 2026 on June 2, 2026, marking the company's most significant push yet to build its own frontier AI stack independent of OpenAI. The centerpiece is MAI-Thinking-1, Microsoft's first large-scale reasoning model, built from scratch on clean commercially licensed data using a sparse Mixture of Experts architecture. Alongside it: MAI-Code-1-Flash, a 5-billion-parameter coding model that outperforms Claude Haiku 4.5 by 16 percentage points on SWE-Bench Pro while using 60% fewer tokens on complex tasks. This is the complete developer guide to all seven MAI models, their specs, benchmarks, deployment paths, and what they mean for the AI development ecosystem. Why Seven Models at Once? The strategic context matters. For three years, Microsoft's AI product surface — GitHub Copilot, Azure AI, Bing Chat, Microsoft 365 Copilot — ran almost entirely on OpenAI models. The Build 2026 announcement is Microsoft's public declaration that it is building a parallel, proprietary model stack. Every new MAI model is trained from scratch using "clean and appropriately licensed data, without distillation from third-party models" — language that directly addresses the intellectual property concerns that have accompanied third-party model licensing. The distribution strategy is equally deliberate. Microsoft is not routing MAI models exclusively through Azure. MAI-Thinking-1 and MAI-Code-1-Flash are available via Fireworks AI, Baseten, and OpenRouter — three infrastructure providers that collectively reach developers who explicitly do not want cloud vendor lock-in. This signals a platform-first posture: Microsoft wants MAI to become a model ecosystem, not just an Azure feature. MAI-Thinking-1: The Reasoning Flagship MAI-Thinking-1 is Microsoft's answer to Claude Opus 4.x and GPT-5.5 on the reasoning side of the model spectrum. The architecture is a 35-billion-parameter active / approximately 1-trillion-parameter total sparse Mixture of Ex

Claude Opus 4.8 shipped today. The benchmarks are a distraction — here is what actually changes about how your agents run tomorrow. Anthropic announced Claude Opus 4.8 at 16:00 UTC on June 3, 2026. The launch post leads with the usual benchmark deltas: SWE-bench Verified up 4.1 points, GPQA Diamond up 2.9, TAU-bench tool-use up 6.4. There is a chart. There is a marketing line about "the most capable agentic model we have ever shipped." If you stop reading there, you will miss the three things that will change how your production agents behave starting tomorrow. I have spent the morning re-running our internal agent harness against Opus 4.8 and reading the model card line by line. Two of the three changes are improvements. One of them is a silent regression that will bite anyone who pinned the model ID. Here is the full picture. What 4.8 actually changes The model card and release notes ship three changes that the launch blog post does not foreground: Cache-aware routing inside long agentic loops. The 4.7 router treated every tool-call cycle as a fresh planning step. 4.8 keeps an internal trace of which cache breakpoints were hit on the previous step and biases the next plan toward extending those traces. In agent harnesses that already use prompt caching aggressively (Claude Code, the Agent SDK with cacheControl: "ephemeral" on the system prompt), cache hit rates jumped from a measured ~46% on 4.7 to ~71% on 4.8 across a 30-step coding loop. The 200k context window now actually behaves at 200k. Anthropic published a needle-in-a-haystack chart in the model card going out to 200,000 tokens. The 4.7 chart got noticeably worse past ~140k tokens; the 4.8 chart is flat. This sounds like a benchmark thing. It is not. It changes the cost equation for "just stuff everything in context" patterns that 4.7 quietly punished by degrading accuracy. claude-opus-4-7 was not aliased. The launch shipped a new model ID — claude-opus-4-8 — and the previous ID is still callable. But if y

⚠️ この記事はアフィリエイト広告（プロモーション）を含みます。リンク先で発生した収益の一部が運営者に支払われますが、読者の購入価格には一切影響ありません。 If you work remote from rural Japan, by the end of this article you'll have two runnable Python scripts: one that computes your exact furusato-nozei (hometown tax) ceiling from your real side-income, and one that scores your electricity contract against your actual kWh log so you stop overpaying. No spreadsheets, no "consult a tax accountant" hand-waving. Copy, run, save money tonight. Result from my own 2025 numbers: ¥41,000 of furusato-nozei reward goods for a net cost of ¥2,000, plus ¥28,400/year shaved off my power bill after switching plans. Total ≈ ¥67,400 recovered, and because I work from home in Niigata, my commute cost to earn it was literally ¥0. The trap: side income breaks the "simple" furusato nozei calculator Every portal (Satofuru, Rakuten Furusato, Furunavi) shows a slider that estimates your ceiling from salary alone. The moment you add freelance/blog/ Kindle income, that slider lies to you. In 2024 I trusted it, donated ¥52,000, and ¥9,000 of it fell outside the deductible ceiling because my side income pushed me into a different residual-tax bracket. That ¥9,000 was just a donation — no tax back. The real ceiling depends on your total taxable income (salary + side hustle minus expenses) and the resident-tax (juminzei) cap of roughly 20% of your income-based resident tax. Here's a calculator that actually folds in side income. It uses Japan's 2026 progressive income-tax brackets. # furusato_ceiling.py — Python 3.9+ from dataclasses import dataclass # 2026 national income tax brackets: (upper_bound_yen, rate, deduction_yen) BRACKETS = [ ( 1_950_000 , 0.05 , 0 ), ( 3_300_000 , 0.10 , 97_500 ), ( 6_950_000 , 0.20 , 427_500 ), ( 9_000_000 , 0.23 , 636_000 ), ( 18_000_000 , 0.33 , 1_536_000 ), ( 40_000_000 , 0.40 , 2_796_000 ), ( float ( " inf " ), 0.45 , 4_796_000 ), ] @dataclass class Taxpayer : salary_income : int # after salary-income deduction (給与所得) side_profit : int #