标签：#ENSO

I have been building an open source tool called Agentic Ledger and it just reached the point where I need more eyes on it than my own. This post is an introduction and an ask. The problem AI agents run unattended. They call LLMs in loops, use tools, spawn sub-agents, and spend real money, and most of that happens where you cannot see it. When an overnight coding loop burns $40 getting stuck on the same failing test, or a multi-agent crew quietly retries itself into a huge bill, you usually find out from the invoice. The observability tools that exist mostly want you to instrument your code with an SDK, and each one speaks one framework. I wanted the opposite: something that watches everything, requires changing nothing, and keeps the data on my machine. What it is Agentic Ledger is a transparent proxy that sits between your agent and the LLM provider. You point your agent's base_url at it, and it records every request and response, assigns each call an action id, works out what it cost, and passes the response through untouched. Your agent never knows it is there. Your Agent -> Agentic Ledger Proxy -> OpenAI / Anthropic / any gateway | SQLite or Postgres | Live dashboard + API No SDK, no decorators, no monkey patching. It works with any framework and any provider because it operates at the only layer they all share: the HTTP call. Everything is local-first. Your prompts stay in a SQLite file on your machine (or your own Postgres). MIT licensed. Try it in two minutes pip install -U agentic-ledger AGENTICLEDGER_UPSTREAM_URL = https://api.openai.com python -m agenticledger.proxy Or with Docker (multi-arch, non-root, Sigstore-signed): docker run -p 8000:8000 \ -e AGENTICLEDGER_UPSTREAM_URL = https://api.openai.com \ -v $( pwd ) /data:/data \ ghcr.io/shekharbhardwaj/agentic-ledger:latest Then point your agent at it: client = OpenAI ( base_url = " http://localhost:8000/v1 " , default_headers = { " x-agenticledger-session-id " : " run-1 " }, ) For coding agents like Claude

We've all had the same experience. You ask your coding agent to integrate with a new platform. It confidently writes code. It references endpoints that don't exist anymore. It misses required headers. It mixes API versions. It hallucinates authentication flows. None of this is surprising. Large language models don't "know" an API. They know about an API from their training data. Even when you hand them documentation, they're still trying to reconstruct a mental model from hundreds or thousands of pages of text. The problem isn't writing code. It's building context. Understanding an API is still mostly manual Every integration starts the same way. Read the authentication docs. Figure out the important entities. Learn the object relationships. Understand the common workflows. Find the endpoints that matter. Jump between documentation tabs for an hour. Only then do you actually start building. Ironically, AI made writing code dramatically faster while leaving this entire process mostly unchanged. Documentation wasn't designed for AI Most documentation is optimized for humans. OpenAPI specifications are optimized for machines. Neither tells the complete story on its own. The spec explains what exists. The documentation explains why it exists. Neither builds a coherent mental model. I wanted a better starting point That's why I built Scout. Scout takes an OpenAPI specification and the accompanying documentation, then synthesizes them into a grounded understanding of the platform. Instead of asking: "Can Claude figure this out?" The workflow becomes: import the API crawl the documentation build an understanding ask questions against grounded context generate integration code expose the same understanding to coding agents through MCP Everything runs locally. No hosted backend. No accounts. No telemetry. The interesting part isn't the AI The AI chat isn't the product. The generated code isn't the product. The MCP server isn't even the product. The product is the context tho

Poland runs a national e-invoicing system called KSeF (Krajowy System e-Faktur). Business-to-business invoices are submitted to a government API in a schema called FA(3) , and the system hands back an official confirmation of receipt. If you sell software to Polish companies, you will meet it. The Ministry of Finance publishes official SDKs for Java and .NET . There is nothing for JavaScript. A full client is a real project: authentication, session handling, certificates, XML signing. But a large share of rejected invoices have nothing to do with any of that. They are structural. A tax ID with a bad checksum. Net plus VAT that does not add up to gross. A date that does not exist. Those are worth catching on your side, before you build a session with anyone. So I pulled that layer out of a product I work on, rewrote it standalone, and published it: ksef-invoice-validate . Zero dependencies, no network calls, runs in the browser. npm i ksef-invoice-validate import { validateInvoiceForKsef } from " ksef-invoice-validate " ; const result = validateInvoiceForKsef ({ invoice_number : " FV/2026/07/1 " , issue_date : " 2026-07-01 " , seller_nip : " 1111111111 " , buyer_nip : " 1111111111 " , amount_net : 1000 , amount_vat : 230 , amount_gross : 1230 , }); Three things in it were more interesting than I expected. The NIP checksum A Polish tax identification number (NIP) is ten digits. The tenth is a checksum over the first nine, each weighted and reduced modulo 11. const weights = [ 6 , 5 , 7 , 2 , 3 , 4 , 5 , 6 , 7 ]; const digits = cleaned . split ( "" ). map ( Number ); const checksum = weights . reduce (( sum , w , i ) => sum + w * digits [ i ], 0 ) % 11 ; if ( checksum !== digits [ 9 ]) { // invalid } There is a small elegance here. The remainder can be 10, and no single digit equals 10, so those numbers simply cannot exist as valid NIPs. You do not need a special case. The comparison rejects them on its own. This alone catches a surprising amount. Most bad tax IDs in t

A few months ago I got obsessed with a question: can you run a real LLM entirely inside a browser tab, with zero backend, zero GPU, and zero install? The answer is yes. Here's what I built. ghost is a single HTML file that downloads a quantized language model into your browser's cache on first visit, then runs inference locally in WebAssembly forever after. Fully offline after that first download. No API key. No npm. No build step. Open the file, pick a model, chat. How it works The inference engine is wllama — a WebAssembly binding for llama.cpp. It runs GGUF quantized models directly in the browser using WASM SIMD. I pin it to a specific version so the JS and WASM files always match (learned this the hard way after a fun debugging session involving mismatched memory imports). Models are downloaded from HuggingFace on first load and cached via the browser's Cache API. On every subsequent visit they load instantly from cache, no network needed. Features Three models: Qwen2.5 1.5B (smart), Qwen2 0.5B (fast), TinyLlama (lightweight) Markdown rendering from scratch — no library, just regex transforms RAG: drag a .txt or .pdf onto the chat window. It chunks the text, embeds each chunk using wllama's embedding API, stores vectors in memory, and retrieves the top-3 relevant chunks on each message. Fully local, fully offline Voice input via the Web Speech API — mic button auto-sends on silence Multi-turn conversation memory capped at 10 turns PWA installable — works on mobile home screen too The hard parts Getting wllama to load from a cached model was genuinely tricky. Blob URLs created in the main thread aren't accessible from wllama's internal Web Worker. IndexedDB chunk reconstruction hit a 2GB ArrayBuffer limit on Windows Chrome. The final solution was using wllama's built-in loadModelFromHF with useCache: true which handles everything internally. The embeddings API requires toggling a flag (embeddings: true) that conflicts with normal chat completion — so I toggle it

Model Context Protocol servers have quickly become the connective tissue between AI agents and the outside world — file systems, databases, APIs, internal tools, you name it. That convenience comes with a catch: the tools, prompts, and schemas an MCP server exposes are a new kind of attack surface, and most traditional scanners simply don't look there. MCPRadar is an open-source project built specifically to close that gap. Why this matters A recent academic study examining nearly 1,900 MCP servers found meaningful security issues in a surprising share of them — general vulnerabilities in roughly 7% and MCP-specific tool poisoning in another 5%. Tool poisoning, prompt injection hidden in tool descriptions, and quietly over-permissioned configurations are easy to miss because they don't look like a "normal" vulnerability — there's no CVE, no obvious buffer overflow, just a tool description that quietly tells an agent to do something it shouldn't. MCPRadar's whole premise is that this class of risk deserves the same rigor as any other part of your CI pipeline. What it actually scans MCPRadar isn't a single-purpose linter — it looks at an MCP server from several angles: Protocol inspection — enumerates tools, prompts, resources, and templates the server exposes, and checks server instructions for suspicious content. Source analysis — walks Python and JavaScript/TypeScript code looking for SSRF, unsafe deserialization, command/SQL injection, Trojan Source tricks, and mismatches between a tool's description and what its code actually does. Configuration review — flags poisoned MCP or agent configuration files, risky hooks, and overly broad permission grants. Supply chain checks — fetches packages without running install scripts, cross-references dependencies against OSV, and can emit a CycloneDX SBOM with hashes and provenance. Change monitoring — stores snapshots in SQLite and diffs them over time, classifying changes as cosmetic, behavioral, or security-relevant so sil

I'm responding directly to Maya Posch's piece on HackADay that was published today. Did that rhyme? I think it did. Community-led open source project hosting site Codeberg has formally announced that projects whose code is largely or fully machine-generated through LLMs and other ‘AI’ tools will no longer be welcome. This follows on the heels of a similar ban on cryptocurrency-related projects. The community vote was on two issues, the first being the notion that scraping of project code for the use in LLMs should be forbidden, which was a motion that easily passed. The second motion was on disallowing projects whose code was substantially generated by LLMs like Claude, OpenAI Codex, and similar. This motion passed with 358 in favor versus 144 against. In the earlier linked blog post the reasoning behind especially this second issue is expanded upon, covering not only ‘license whitewashing’, but also the direct and indirect hardware costs, with the expanding ‘AI’ datacenter hyperscaling having massively increased hardware costs for Codeberg over the past years, as the costs have been largely externalized. Also covered is the aspect of these LLM-based tools destroying the OSS community, which is something that is backed up by recent studies. Even if we ignore that such LLM-tools are destroying the cognitive abilities of its users, there’s an argument to be made that if LLM-scraping is disallowed, then it’s consistent to also not allow LLM-generated code. In the Terms of Use you can see these changes, both for LLMs and for cryptocurrency projects. Thanks to [mk-fg] for the tip. Credit is due to the original HackADay.com Article by Maya Posch post contents, but I would like to respond to each point here while preserving what was published on 7-24-2026. Scraping of Project Code for the use in LLMs should be forbidden If LLMs are rendering code trained on GPL-3 open-source software, then its effectively bypassing the license through intellectual property theft by directl

GitHub热门项目 | Your personal intelligence agent. Watches the world from multiple data sources and pings you when something changes. | Stars: 10,756 | 257 stars this week | 语言: JavaScript

GitHub热门项目 | A Python library for extracting structured information from unstructured text using LLMs with precise source grounding and interactive visualization. | Stars: 37,881 | 401 stars this week | 语言: Python

GitHub热门项目 | kubernetes, reimplemented in Rust | Stars: 618 | 42 stars today | 语言: Rust

GitHub热门项目 | Declare your digital independence | Stars: 2,906 | 64 stars today | 语言: Rust

GitHub热门项目 | The open-source alternative to Claude Cowork (powered by opencode) | Stars: 17,288 | 92 stars today | 语言: TypeScript

GitHub热门项目 | | Stars: 7,854 | 5 stars today | 语言: TypeScript

GitHub热门项目 | RyukGram, The Instagram tweak for iOS power users. | Stars: 367 | 11 stars today | 语言: JavaScript

GitHub热门项目 | Private AI platform for agents, assistants and enterprise search. Built-in Agent Builder, Deep research, Document analysis, Multi-model support, and API connectivity for agents. | Stars: 18,112 | 50 stars today | 语言: Python

GitHub热门项目 | Jenkins automation server | Stars: 25,805 | 179 stars today | 语言: Java

GitHub热门项目 | Amnezia VPN Client (Desktop+Mobile) | Stars: 13,587 | 515 stars today | 语言: C++

Every service I've worked on eventually grows the same scar tissue: a retry loop copy-pasted into six files, a circuit breaker bolted onto the payment client after an outage, a timeout wrapper someone wrote at 3 a.m. Each one slightly different. None of them talking to each other. And when things go wrong, nobody can answer the only question that matters during an incident: what is the resilience layer actually doing right now? Java solved this years ago with resilience4j . .NET has Polly . Node.js... has pieces. The gap I evaluated what the ecosystem offers before writing a single line: opossum is the best-known circuit breaker, mature and well maintained. But it's only a circuit breaker — retry is rudimentary, there's no bulkhead, no composition. Metrics need a plugin. cockatiel is the closest thing to Polly: retry, breaker, timeout, bulkhead, composition. I genuinely like its design. But observability is where it stops — no native metrics, no pipeline-wide correlation — and maintenance has slowed. The Sindre micro-libs ( p-retry , p-timeout , p-limit ) are excellent at exactly one thing each. But resilience is a system : a retry that doesn't know the circuit is open will happily sleep through backoff to hammer a dead dependency. Isolated pieces can't coordinate. And there was one thing nobody documented properly, which became the reason I finally started typing: Ordering is the whole game Take four policies: retry, circuit breaker, timeout, fallback. The same four, nested in two different orders, produce two very different systems: retry ( circuitBreaker ( timeout ( fn ) ) ) // A circuitBreaker ( retry ( timeout ( fn ) ) ) // B In A , every attempt flows through the breaker, so the breaker sees the dependency's true failure rate — and when the circuit opens mid-retry, the retry finds out immediately. In B , the breaker sees one outcome per retry cycle : three real failures against the dependency count as a single failure. The circuit opens far later than the depe

After you deploy half a dozen AI agents across a team, something weird happens. Friday afternoon, release day. The PM says their AI summarized the change impact. The dev says their AI reviewed the code and found nothing. QA says their AI ran the test suite and everything passed. Then production breaks. You dig through the logs and all you see is "system call." No way to tell which agent made which call, when, on what context, acting on whose behalf. Three agents sharing one service account, one API key, zero accountability. The humans end up taking the fall, and you can't even figure out which human to talk to. This isn't a thought experiment. It's what happens when you bolt AI assistants onto existing infrastructure without thinking about identity. Buy a batch of API credits, create a service account, share it across the team, done. That works fine when one person uses one assistant for their own work. It falls apart the moment multiple agents run in parallel across different roles. Permissions break first. A competitive research agent needs access to all project channel discussions. A code review agent should only see PRs and repository messages. That distinction doesn't exist in the service account model, which has a single binary switch: can access or cannot access. Teams work around it by manually creating groups, forwarding messages, and setting permission boundaries by hand. Add more agents and this manual isolation starts to crack. Some teams we've talked to ended up with over a dozen separate groups just to control agent visibility, with humans acting as message routers between them. At that point the AI is making things slower. The work history problem is more concrete. An engineer who's been on the team for three months, you know what they're good at, what they're sloppy at, which module they crushed last sprint. Next time you assign work, you use that information. An agent that's run a hundred tasks? Completion rate, rejection count, which task types it

A Beijing startup just out-shipped every US lab's open-weight strategy On July 16, Moonshot AI — the Alibaba-backed startup behind Kimi — put Kimi K3 behind an API. Today, July 27, the full weights land on Hugging Face. No waitlist, no "responsible scaling" essay, no six-month delay between "we built something scary" and "here, run it yourself." Just 2.8 trillion parameters, open, on the day they said it would happen. That's not a small model with a big number attached. It's the largest open-weight model ever released, full stop. And unlike most "open" releases that quietly underperform their closed competitors, K3 is winning on the benchmarks developers actually care about. Let's get into what's real and what's marketing. The numbers K3 is a mixture-of-experts model: 2.8T total parameters, but it only activates 16 of 896 experts per token. That's the trick that makes a model this size runnable at all — you're not paying compute for the full 2.8T on every forward pass. The architecture story is Kimi Delta Attention (KDA), a hybrid linear attention mechanism Moonshot claims delivers 6.3x faster decoding, plus "attention residuals" that improve token efficiency by 25% for roughly 2% extra compute. Whether that holds up under independent scrutiny is still TBD, but the direction — make huge models cheap to serve — is the correct one, and it shows up in the token counts: K3 uses 21% fewer output tokens than its predecessor, K2.6, for comparable tasks. Context window: 1,048,576 tokens. Flat pricing, no context-length tiering — a real advantage over providers who quietly double your rate past 128K. Benchmarks that matter: Benchmark K3 Comparison Frontend Code Arena 1679 Elo (#1) Claude Fable 5: 1631, GPT-5.6 Sol: 1618 GPQA Diamond 93.5% Best open-weight score ever published GDPval-AA v2 1687 (#3) Behind Claude Fable 5 Max (1815), GPT-5.6 Sol Max (1747.8) — ahead of Claude Opus 4.8 (1600) Artificial Analysis Elo 1547 +732 over K2.6 Read that middle row again: an open-weight

AI coding tools have crossed a real threshold in the past year. Cursor and Windsurf count millions of active users. VS Code and JetBrains ship with built-in completion. Tencent Cloud demoed CodeBuddy NPC last month, where an agent takes a task spec, writes the code, opens a PR, runs CI, and fixes failures autonomously until everything goes green. You type a function signature and the model fills in a dozen lines before you finish thinking. Drop a comment saying "add unit tests" and a test skeleton appears in seconds. Individual coding speed is up somewhere between 3x and 5x by most team accounts. Pull the lens back from the editor to the team level and the picture changes. More code ships faster, but review queues grow longer, test environments get locked more often, and wait times between handoffs actually stretch out. A developer spends 20 minutes writing a feature, waits two hours for review, fixes comments, pushes again, and the staging environment is busy. QA posts failures in the group chat and the developer misses the message while on something else. Hours pass. Actual coding time might account for a tenth of the total delivery cycle. The rest is coordination, waiting, messaging, and context switching. The faster code gets written, the more congestion piles up behind it. The single-agent loop that products like CodeBuddy NPC demonstrate works cleanly for isolated work: one agent plans, codes, tests, and fixes until it passes. But any non-trivial feature in a real team crosses multiple roles. PMs confirm requirements. Tech leads do architecture reviews. QA runs regression in staging. Ops checks resource configs before deploy. Between each handoff today, someone pings Slack saying "PR up for review," drags a ticket from In Dev to Ready for QA in Jira, or scrolls through doc history trying to remember what came up in the last review. The agent can write the code, but it has no idea who to ping for review, how to provision a test environment, or why the last vers