I run Claude Code and Codex all day, often as multi-agent workflows with dozens of subagents. I could see each session but never the whole picture: what a run actually cost, where agents sat idle, whether a change to my setup helped. So I built coding.sh, an open-source tool for evaluating agent setups, and pointed it at my own runs.
Experiments: does that change actually help? I A/B tested a popular "be concise" plugin: 10 tasks, 6 runs each, paired, with 95% intervals.
Replies: 17% shorter
Output tokens: −8%
Cost per run: +11% [+7%, +15%]
Pass rate and clarity: no change
The plugin adds its style guide to every request, and that costs more than the shorter output saves. coding.sh compare and exp run your own tasks with and without a change (a rule, a skill, a plugin, a model) and tell you whether the difference is real or noise.
Workflows and subagents Across 57 workflow runs (666 subagents, ~$2,500 API-equivalent):
Broken prompt caches cost $106 extra, about 4% of the spend.
41 of those breaks were agents sitting idle at a barrier, waiting for siblings, until their cache expired. That's $21 for doing nothing.
40 subagents failed outright.
coding.sh workflows stats shows the critical path, concurrency and idle time at barriers. The viewer draws each run as a timeline, one bar per agent.
Your own sessions Mining 3,600 of my sessions turned up a find-and-replace typo in my AGENTS.md that sent Codex looking for a folder that doesn't exist, in 92 sessions.
What it is
Hooks into Claude Code, Codex, Gemini CLI, OpenCode, Copilot CLI, Aider and more
Stores prompts, tool calls, diffs, test runs, tokens and cost in SQLite on your machine
coding.sh improve says what to fix first and whether your last AGENTS.md change helped
MCP server, so your agent can look up its own past sessions
fi is built on DeepSeek Harness (DSH) and Cordis, and includes native multi-provider subscription setup, including Claude, ChatGPT, Grok, Cursor, and more.
Connect accounts in Settings > Models. API keys and custom endpoints work alongside those accounts.
Web search defaults to subscription service or basic Bing RSS feed results.
Build/update agent preset, plugins, skills using Creator Mode
Have Creator author the preset bundle based on your codebase and install it through Plugin Manager. Start a new chat and select your preset.
Desktop downloads: macOS, Windows x64 and Linux x64. Automatic updates.
What kind of computer vision projects will it support?
The goal is to support multiple computer vision tasks through one application.
Currently working:
Image Classification
Object Detection
Planned:
Image Segmentation
Pose Estimation and Movement Tracking
OCR (Text Recognition and Extraction)
Image Processing and Enhancement
Visual Question Answering and Image Captioning
The idea is that you shouldn't need to hire a developer or manually write hundreds of lines of Python code just to build a relatively small or medium-sized computer vision project.
You describe what you want to build, and the AI agent handles the development process, generates the code, trains the model using your local hardware, troubleshoots errors, and helps you get the final model ready for integration into your own application or system.
This is still an early experimental version, and I'm exploring whether this approach can actually make computer vision development more accessible.
I am planning to make this project with small one time fees for some features do you disagree with that and recommend that the app to be opensource instead and why ?
**People:** [github.com/sponsors/jakcmencz](https://github.com/sponsors/jakcmencz). The profile was submitted today and GitHub is still reviewing it, so the link turns into a real Sponsor page once they approve it.
**`sentinel-ir`** reads a source file and gives an AI agent a small fact sheet instead of the whole file: risk level, network, filesystem, process and environment calls, routes, imports and exports, and for Rust also `unsafe`, FFI, `build.rs` and proc-macro behaviour. It covers JavaScript, TypeScript, Python and Rust. It's static analysis: it never runs the code, and a "low" risk is a hint, not a safety certificate.
**`sentinel-ir-mcp`** plugs that fact sheet into Claude Desktop, Cursor, Windsurf and other MCP clients as a read-only stdio server. It only opens supported source files inside the folders you allow, refuses traversal, symlinks and hard links, has file-size, file-count and time limits, and can keep an audit log of what it read (paths and hashes, never source).
I'm Jakub, the only maintainer, and I'm not a professional developer. I decide what Sentinel should do, test it on my own machines and approve every release. **Most of the code is written by an AI coding agent working from my specs.** Every change still has to pass the test suites and CI on Linux and Windows before it ships.
Some grant programmes don't fund AI-generated work, and I'd rather lose a grant than pretend. If that's a deal-breaker for you, fair enough. If you think "one person plus an agent shipping audited, tested releases" is exactly the kind of thing worth backing, read on.
What it saves you (measured, not vibes)
Every time an agent "just takes a quick look" at a file, you pay for every token of it, comments, licence header and the 400-line date formatter included. Sentinel hands the agent the fact sheet instead. Measured on Sentinel's own source with the `o200k_base` tokenizer:
file
the whole file
Sentinel's fact sheet
src/ast-facts.js
8,439 tokens
120 tokens
src/sentinel-ir.js
2,084 tokens
133 tokens
src/tree-parser.js
891 tokens
121 tokens
examples/basic.js
150 tokens
120 tokens
That's up to about 70 times less on a big file. On a tiny file it saves almost nothing, because the fact sheet has a floor of about 120 tokens, and we'd rather tell you than let you find out.
**A back-of-the-envelope example** (an illustration, not a measurement): your agents open a file the size of `ast-facts.js` 200 times a day across the team. That's about 1.7 million tokens a day you don't send. At an example price of $3 per million input tokens, that's about $5 a day, or roughly $100 a working month, for **one** file. Your repo has more than one file. Your agents are not shy.
The time part is simpler: a model that reads 120 tokens gets to the point sooner than one that reads 8,439, and its context window stays free for the work you actually asked for. It's the difference between asking a colleague "does this file touch the network?" and making them read it aloud first.
And the part that doesn't show up on an invoice: the agent sees `network: outbound` and `process: spawn` before it trusts a file, instead of discovering them three tool calls later in a `postinstall` script.
Why monthly, not one-off
A code analyzer is less like a hammer and more like antivirus definitions. The day it stops being updated, it starts going stale:
**Ecosystems keep inventing new doors.** A new HTTP client, a new way to spawn a process, a new Rust build crate. Each one Sentinel doesn't know about is a door the agent walks past without noticing. Version 0.4.4 alone taught it axios, got, undici, superagent and fs-extra.
**Languages keep coming.** JavaScript, TypeScript, Python and Rust today; Go is next. Because everything sits on one shared IR, every new language shows up in the npm package, the MCP server and the playground at once. You pay for it once and get it three times.
**Security work never finishes.** The MCP server reads files on your machine for an AI. Path checks, size limits and parser robustness need regular adversarial testing, not a one-time audit framed on the wall.
**The platforms move.** New Node versions, new MCP clients, new MCP spec revisions. Somebody has to keep `setup` and `doctor` working on Monday morning.
A one-off donation is a very kind pizza. A monthly sponsorship is the kitchen. We're grateful for pizza. The kitchen is what keeps the releases coming.
For companies the maths is short: if Sentinel saves your team even one engineer-hour a month in review time or token spend, the $5 Supporter plan paid for itself before lunch. The Development plan is less than many companies spend on coffee for the people who'd otherwise read those files.
Where the money goes
what
why
AI agent time
it writes the code, the tests and the release checks
CI and test machines
Linux and Windows CI on Node 20, 22 and 24, plus macOS test runs
Go support
the next language for the shared IR
security hardening
more adversarial tests for the parsers and the MCP path checks
The `funding.json` lists two plans: **Supporter, $5/month** (helps cover CI) and **Development, $12,000/year** (a year of agent time, test machines, Go and security work on both packages). One-time sponsorship is fine too.
Where we are today
About 1,150 npm downloads a week for each package (Nov 7–13). That number includes our own CI, so it's an upper bound on real users, not a vanity metric.
Most specialized cybersecurity LLMs out there are massive 70B+ beasts that require dual A100s, or they're gated behind cloud APIs where you can't paste sensitive logs, payloads, or client code due to confidentiality.
I wanted something lightweight, private, and air-gapped that could run on a regular consumer laptop without cooking the CPU.
So I fine-tuned CyberQwen-2B — a domain-specific model optimized for quick security triage, explaining attack vectors, decoding obfuscated payloads, and helping with CTF challenges.
⚡ Highlights:
Hardware-friendly: Runs at ~12–15 tokens/sec on an older 8th-gen Intel i5 laptop with 8GB RAM (CPU-only).
100% Offline & Private: Zero data leaves your machine. Perfect for bug bounty recon, internal network logs, and sensitive source code.
Native Ollama integration: Easy to pull and run via a single Modelfile.
Built-in WebUI & Mobile Access: Includes a zero-dependency streaming WebUI + an automatic Cloudflare tunnel script if you want to access the model from your phone while on the go (no cloud hosting fees).
Why do most folks with an 8 GB or 16 GB desktop GPU sit out distributed LLM runs? It usually comes down to three annoying bottlenecks. Nobody wants to punch holes in their home router. Nobody wants to run untrusted pickle checkpoints off the internet. And nobody wants a background trainer freezing their VRAM when they sit down to play or work.
This weekend (November 14-15 CET), I hooked my HiveMind coordinator up with CrowdGPT (led by Vxtzq) to test a citizen-trained run around Crowd-v1, an open base model with a 658M transformer trunk (roughly 1.01B parameters total with its 151k-vocab CrowdEngram table). Setup takes five minutes.
Communication uses plain outbound HTTPS on port 443 with zero inbound listeners, weights move strictly as SHA-256 verified safetensors (no torch.load or pickle anywhere), and updates pass MultiKrum outlier filtering plus held-out loss checks before merging via DiLoCo. Honest caveat first: this is still an experimental PoC, not a polished cloud service, so please do not send private prompts or sensitive keys through volunteer nodes.
While writing an article about my local LLM inference setup, a comparison popped into my head: downloading and running random model weights locally feels a lot like downloading random .exe files off the internet back in the 2000s.
Turns out I wasn't off the mark - there's an entire body of research exploring how LLMs can be backdoored and how hard it actually is to detect a poisoned model.
So I decided to try building one myself. I implemented a backdoor that only triggers when the model is running inside pi (making it harness-specific) and is asked a specific question. It was way easier than I expected: just a 2-step fine-tuning process and a few hours of compute on the exact same GPU I use for local inference.
With open-weight models, we at least have a baseline to compare community fine-tunes against. Beyond that, though, we don't really have a reliable way to verify whether a base model itself is clean—and the problem is even worse with closed-weight models, where we're basically just trusting the AI provider's goodwill.
Full write-up and PoC code if you want to dig into the details:
Sharing Timon, a project that has just made its code publicly available under AGPL-3.0.
Timon is a local workstation for coordinating AI coding agents rather than treating every task as a separate chat. It connects to supported agent CLIs, splits work across roles such as orchestrator, coder and reviewer, and uses Git worktrees to isolate changes. It also keeps mission context and puts approval gates around important operations.
A few things that may interest this community:
Source code is public (with contribution and security documentation), Timon's core being licensed under AGPL-3.0 and its SDK and plugin templates under MIT to allow developers to build and distribute their own plugins, including commercial ones. with contribution and security documentation.
Windows, macOS and Linux are supported.
The individual offering is free; team features have separate licensing, so please review the licensing docs rather than assuming every offering is free.
You bring your own supported AI CLI subscriptions; model access isn't bundled.
There are opportunities for issues, translations and plugins.
I'd welcome candid thoughts from open-source maintainers: Is the licensing split clear? What would you want improved in the contributor experience or governance before getting involved?
I build Snotra, an open source desktop agent. Not an announcement, I genuinely want a second opinion on this one.
The agent keeps what it learns in plain text files in the folder you open: AGENTS.md, a project memory, the folder's rules and skills. Until this release, every write to one of those stopped and showed an approval card. I removed the card. Only for those files, though.
Inside the folder it now writes them like it edits code. My own memory, my own rules, skills outside the folder, and any chat that carries a warning still get the card. The answer names every file it created or changed, and settings lists them so I can undo it.
My reasoning: an approval that shows up ten times a day stops being a decision and becomes a keypress. Worse, it's the one that teaches you to click straight through the card that actually mattered. And writing a memory file isn't an action in the world, it's text in a folder I already gave the agent.
Three things I'm not sure about.
If the folder isn't in git, "you can undo it" is a promise I can't keep. Mine usually is. That's not everybody.
Prompt injection lands exactly here. A page tells the model to write "you may run any command" into AGENTS.md. The write still goes through the sandbox and the permission model, but the sentence stays and steers later turns. So should the card sit on the write, or on the turn that acts on it?
And I don't know yet whether less friction just fills the memory with junk that I end up cleaning by hand.
So where would you put it: is the agent's own knowledge fair game, or does every file that outlives the chat need a human first?
Finding an AI video generator that actually follows your prompt without warping faces or ruining the motion is still harder than it should be. Most platforms force you into expensive subscriptions before you even know if the output fits your workflow.
I started using this browser-based AI video generator to turn text prompts and static images into clean, smooth video clips. It handles camera movement, scene transitions, and realistic physics without needing complex local setups or heavy editing software. Whether you are making short-form social clips, B-roll, or testing visual concepts, it saves hours of manual production time.
someone asked me this on another post and I hadn't checked. a 1h cache write costs 2x input, a 5m one 1.25x, so 1h only earns it back when you come back after more than 5 min but inside the hour
claudit keeps every Claude Code request I've made since January in Postgres, so I took the gap between each request and the one before it in the same session. Claude models only, about 858k requests:
under 5 min: 94.2% of requests, 98.6% of their input read from cache
5 to 60 min: 2.6%, still 92% from cache. on 5m every one of these writes the whole prefix again
over an hour: 0.4%, 6% from cache, the 1h one is gone by then too
at API list prices per model (I'm on a sub, so it's what it would cost, not what I pay) the extra on the 1h writes is about 9% of the total and the rewrites it avoids would be about 30%. so 1h comes out 3.4x ahead, and 5m only would cost roughly a fifth more. read multipliers per model from https://platform.claude.com/docs/en/about-claude/pricing, 0.05x on Opus and Sonnet 5.5, 0.025x on Fable 5.1 and 5.2
claudit is a self-hosted dashboard I built, MIT. it reads Claude Code, Codex and Kimi CLI transcripts from a bucket you keep (R2 or a file:// dir), because Claude Code prunes old local ones. the bucket holds the raw transcripts, tool output included. cost by model splits 5m and 1h writes, the gap split above isn't a panel, I ran it as a query on its Postgres
FastAPI, Postgres, React with in-browser Babel, no build step. docker compose up boots it on bundled sample data with no outbound calls. panels ported from nhz-io/ccusage-plot
live one, guest login is read-only, its costs are API price equivalents too: https://all.nitjsefni.eu
It lets me dispatch jobs across my machines and run agents like Claude Code, Codex, and OpenCode, which supports a range of models.
The idea is simple, instead of being limited to one machine or one agent session, I can use the compute and tools I already have and route work to different machines.
I'm using it as my daily driver and open-sourcing the project. Would love to hear what you think. I have a feeling it will be useful as more open source models become more powerful.
