标签：#ens

API documentation has a reliability problem. The code gets updated; the OpenAPI spec gets forgotten. The spec gets updated; the TypeScript client doesn't regenerate. By the time an enterprise client asks for your API contract, the document you hand them describes a system that no longer exists. Baklava, an open-source library by Iterators , solves this structurally: documentation is generated from the tests that verify your actual API behaviour, so it cannot drift. The problem Documentation drift is the default state of any API that lives long enough. The causes are well-understood: docs and code are maintained separately, documentation updates require extra discipline at every PR, and no automated check catches a route signature change that wasn't reflected in the OpenAPI file. The consequence is real. Clients building against a stale spec hit integration errors in production. Internal teams onboarding to a service spend hours reconciling the documented contract with actual behaviour. TypeScript front-ends break when an API response field changes without a corresponding client update. The problem compounds as the API grows. The solution Baklava integrates into your existing test suite. When routing tests run, baklava observes each request and response, infers the API surface, and generates documentation as a test output, not as a separate build step, not as a manually-maintained file. In baklava, the test is the documentation spec. Instead of a standard assertion block, each route is defined with path() , supports() , and onRequest() scenarios that both verify the API behaviour and describe it for documentation output: ​`// The test IS the documentation spec class UserApiSpec extends AnyFunSpec with BaklavaPekkoHttp[Unit, Unit, ScalatestAsExecution] with BaklavaScalatest[Route, ToEntityMarshaller, FromEntityUnmarshaller] { path("/users/{userId}")( supports( GET, pathParameters = p Long , summary = "Get user by ID" )( onRequest(pathParameters = 1L) .respondsWith Use

There's no shortage of React UI kits on npm. Search for one right now, and you'll get hundreds of results, most with the same seven button variants and a Storybook someone abandoned halfway through. So when I open-sourced brightframe — pulled out of a real coworking site I built, LAN — I didn't really want to write the usual "here's our 70 components, look how many there are" post. Component count isn't interesting. Anyone can list props and screenshot a button in five colors. What actually took time, and what I think is worth writing about, is the part that happens after the README makes a claim. "Tree-shakeable." "Server Components-safe." "Accessible." Those are three words I typed pretty confidently early on, and then, more recently, I sat down and tried to prove myself wrong on each one. This post is what that turned up. "Tree-shakeable per component" — okay, but how much, actually? Every component ships as its own entry point: import " brightframe/tokens.css " ; import " brightframe/Btn.css " ; import { Btn } from " brightframe/Btn " ; Saying "unused components add nothing to your bundle" costs nothing. I added size-limit to CI so the claim has to keep being true, not just have been true once when I wrote the sentence: Entry Minified + brotli Whole kit ( import { ... } from "brightframe" , JS) 40.13 kB Whole kit ( brightframe/style.css ) 11.83 kB One component ( brightframe/Btn , JS) 641 B One component's styles ( brightframe/Btn.css ) 890 B 641 bytes vs. 40 kilobytes. That gap is the whole reason the per-component entry points exist, and now if a refactor accidentally makes Btn drag in half the kit, the build just fails instead of me finding out from a bundle-size complaint six months later. "Server Components-safe" — this one had an actual bug in it RSC has no hook dispatcher at all. A component needs "use client" if it does one of two things in its own source: calls a hook, or wires up a DOM event handler in its own JSX. I wrote a little script ( scripts/che

Runbooks still say "renew the SSL certificate" when the browser warning is obsolete protocol . The certificate can be brand new. The tunnel is still TLS 1.0. This is a shortened English note. The tables, handshake diagram, and OpenSSL CLI checks live on the original post: https://sunshout.tistory.com/2206 SSL vs TLS (the only distinction that matters) SSL is a Netscape protocol from the 1990s. SSL 3.0 is withdrawn (POODLE and friends). What every browser speaks now is TLS , currently 1.2 or 1.3. People still say "SSL cert" because vendors sold that phrase. The file is an X.509 certificate. The handshake that uses it is TLS. SSL TLS Who Netscape IETF Versions you might still see 2.0 / 3.0 (disable) 1.0 / 1.1 (disable), 1.2 / 1.3 (use) Status Forbidden Required If a ticket says "SSL is broken", translate it to: which TLS version did the handshake negotiate, and which cipher? The tunnel only has three jobs Confidentiality — encryption so a tap does not yield plaintext. Integrity — a MAC (today: AEAD) so a MITM cannot flip bits unnoticed. Authentication — the certificate binds this hostname to a key a CA will vouch for. https is that tunnel. It is not "the lock icon means the page is safe to click." It means the bits on the wire are for that name, encrypted, and unmodified. XSS and a malicious origin are a different layer. The outage that is not the certificate Symptom: new Let's Encrypt leaf, browsers still scream obsolete TLS or refuse the handshake on phones. Cause: nginx/Apache/openssl still allow TLS 1.0/1.1, or the server has no 1.2+. Renewing the cert does nothing. Check, do not guess: # must fail openssl s_client -connect example.com:443 -tls1 # must work openssl s_client -connect example.com:443 -tls1_2 nginx: ssl_protocols TLSv1.2 TLSv1.3 ; ssl_prefer_server_ciphers off ; Keep TLS 1.2 next to 1.3 if you still have old Android or old Java. New services can prefer 1.3. What to put in the cipher line Key exchange: ECDHE (forward secrecy). Static RSA key exchange

My vision a lightweight, permission-headache-free Docker setup for running OpenCode, uv, and untrusted Python code without risking your host OS. When contributing to unfamiliar open-source projects or letting AI coding agents (like OpenCode ) run terminal commands, there's always a slight hesitation. What if a build script touches my system Python, or a rogue command wipes host files? To solve this, I built saferun a zero-trust, disposable Docker sandbox designed specifically for Python developers and AI agent workflows on macOS and Linux. Here’s how it works, the permission nightmares I had to solve, and how you can set it up in under two minutes. The Goal I wanted a workspace that gave me: Absolute Isolation: Runtime scripts, pytest , ruff , and AI agent commands execute strictly inside a disposable Linux container. Seamless IDE Integration: Files edited inside PyCharm or VS Code on the host machine sync instantly with the container. Zero Permission Headaches: Any files generated inside the sandbox belong to my host user account—not root . Persistent Speed: Package downloads cached permanently via uv so environment startup stays millisecond-fast. Isolated Credentials: Global SSH and Git keys remain safely on the host machine. Solving the "Non-Root" Docker Nightmare The hardest part of containerized dev environments is file ownership. If you run Docker as root , any file your AI agent generates belongs to root , locking you out on your host machine. If you pass your local user ID ( -u "$(id -u):$(id -g)" ), Docker mounts non-existent directories as root:root , causing Permission Denied crashes when tools like uv try to write to cache folders. saferun solves this inside the base Dockerfile by pre-creating cache directories and granting open write permissions upfront: FROM python:3.12-slim # Install curl (needed to install OpenCode) RUN apt-get update && apt-get install -y --no-install-recommends \ curl \ && rm -rf /var/lib/apt/lists/ * # Install uv globally RUN pip

What makes a form portable? Not JSON alone. Its validation, conditions, collections and submission semantics must survive the trip too. I wrote about the architecture behind Modyra and the trade-offs involved. Your Form Is Not Portable If It Contains Callbacks Most form libraries help us manage forms inside an application. They track values, execute validators, expose errors and eventually produce a submission payload. That works well until the form needs to exist somewhere else. Perhaps its structure comes from a backend. Perhaps a visual builder generates it. Perhaps multiple applications must render it. Perhaps the server must independently validate the same conditional rules used by the browser. At that point, the form is no longer just component state. It is a contract. And most form abstractions cannot cross that boundary. The portability illusion Consider a typical conditional validator: const form = createForm ({ defaultValues : { country : ' IT ' , vatId : '' , }, validators : { onChange : ({ value }) => { if ( value . country === ' IT ' && ! value . vatId ) { return { fields : { vatId : ' VAT ID is required in Italy ' , }, }; } }, }, }); This is perfectly reasonable application code. It is also not portable. The callback cannot travel through an API as JSON. A Java service cannot execute it. A visual editor cannot reliably inspect it. Another runtime cannot reproduce its meaning without receiving executable source code. We can serialize the values around the callback, but not the behavior itself. This leads to an important distinction: A form configuration is not a portable form contract if part of its meaning still lives inside executable callbacks. The obvious shortcuts are dangerous There are several tempting ways to work around this limitation. Serialize the callback as source code { "condition" : "value.country === 'IT'" } The receiving application must now parse or execute an expression encoded as text. That creates immediate problems: the expression

GitHub热门项目 | 🪄 Data Formulator is an interactive AI-powered data analysis system makes it easy to connect, explore and visualize data. | Stars: 16,944 | 668 stars this week | 语言: Python

GitHub热门项目 | Autonomous experiment loop extension for pi | Stars: 7,807 | 95 stars today | 语言: TypeScript

GitHub热门项目 | Open-source AI browser agent for Chrome and Firefox (monorepo) 🧠 | Stars: 905 | 35 stars today | 语言: JavaScript

GitHub热门项目 | Self-organizing AI second brain for Obsidian + Claude Code. Drop any source and Claude reads, links, and files it into one connected knowledge graph of plain Markdown you own. AI note-taking, personal knowledge management (PKM), and an open-source Notion alternative. Based on Karpathy's LLM Wiki pattern. | Stars: 11,516 | 272 stars today | 语言: Python

GitHub热门项目 | A single CLAUDE.md file to improve Claude Code behavior, derived from Andrej Karpathy's observations on LLM coding pitfalls. | Stars: 206,158 | 491 stars today | 语言:

Your AI agent returns a signed receipt: 0 defects found. The signature is valid. The receipt has not been altered. The agent was authorized to run the check. The result can still be wrong. Perhaps the scanner hit a rate limit and silently converted eleven failures into eleven empty results. Perhaps a watchdog inspected 8 machines and issued a conclusion about 68. Perhaps a database health check ran select 1 successfully while the application was failing because a required column did not exist. In every case, the software can produce a well-formed result. It can even sign that result correctly. What it cannot prove is that it measured the claim the business thinks it measured. That distinction is becoming one of the most important problems in agent infrastructure: authentic receipt != adequate measurement authorized action != correct conclusion zero findings != complete inspection A signature answers only part of the question Cryptographic signatures are valuable. They can prove who signed an object and whether its contents changed after signing. They do not prove: that the check actually ran that it reached the intended target that it measured the right population that the sample supports the claimed conclusion that exceptions were not converted into zeros that a passing control answered the business question This is the difference between provenance integrity and measurement integrity . Provenance integrity asks: Who made this statement, and was the statement altered? Measurement integrity asks: What was actually observed, how much of the target was covered, and is the conclusion justified by that observation? An agent work protocol needs both. Otherwise, a signature can turn uncertainty into durable false confidence. Three failures with the same shape This article grew out of a thoughtful comment from Heinrich Neb on the first article in this series. He described three incidents from one week. First, a harvesting tool scanned 16 public repositories. Five returned

So I spent the last two weeks running two open-source AI agents in parallel: OpenClaw and Hermes Agent (from Nous Research). I went in expecting to pick a winner. I came out realizing it's not really a "pick one" situation at all. These two projects represent two very different design philosophies — one is built around connection and control , the other around learning and growth . Which one fits you depends on whether you want an obedient tool or a companion that evolves with you. Here's my full breakdown after using both for deployment, daily tasks, and the general "living with it" experience. Two philosophies, two products OpenClaw takes a gateway-first approach. It's a persistent controller that handles routing, permissions, multi-channel integration, and skill orchestration, with pluggable models. The core promise: connect everything, execute predictably. Hermes Agent is built around a learning loop. The agent creates and refines its own skills as you use it, and keeps deepening its model of you over time. The core promise: the more you use it, the better it knows you. A rough analogy: OpenClaw is like a senior assistant who strictly follows the instruction manual — plus a universal adapter. Hermes is more like a teammate who writes their own manual after every task and keeps improving it. The four things that actually differentiate them 1. Skills: ready-made ecosystem vs. self-compounding OpenClaw: human-written skills distributed via ClawHub. Huge ecosystem, works out of the box. Hermes: the agent generates and iterates on skills by itself. Less rich in the short term, but it compounds over time. 2. Memory: good enough vs. actually remembers OpenClaw's default memory is fine (files and Markdown supported). But Hermes' four-layer memory architecture is noticeably more persistent — the difference becomes very tangible after a couple of weeks of use. 3. Autonomy: decisive vs. controllable Hermes is extremely strong when the task is clear — it often nails things

The deepfake epidemic in schools is affecting more than students. Four teachers tell WIRED about becoming targets of sexualized, AI-generated content—and how difficult it was to find accountability.

If you're wiring MCP servers into an agent and want to check them for prompt injection, tool poisoning, or supply-chain risk before you trust them, there are now a handful of open-source options. This is a factual, no-benchmarks comparison of the three I could actually find and read the docs for: our own sentinel-scan-cli , Cisco's mcp-scanner , and what used to be Invariant Labs' mcp-scan . One thing worth flagging up front: Invariant Labs' mcp-scan repo ( github.com/invariantlabs-ai/mcp-scan ) now redirects to github.com/snyk/agent-scan . The project has been absorbed into Snyk and rebranded as "Agent Scan" (package snyk-agent-scan ). If you're comparing tools based on older blog posts that reference "Invariant Labs mcp-scan" as a standalone, no-account CLI, that's out of date — running it now requires a free Snyk account and an SNYK_TOKEN API key ( export SNYK_TOKEN=... ) before the CLI will scan anything. I'm comparing against the current Snyk Agent Scan README since that's what the repo actually ships today. All claims below are pulled directly from each project's public README as of 2026-08-24. No invented features, no synthetic benchmarks — this is a "what does the doc actually say" comparison, not a lab test. Feature comparison sentinel-scan-cli Cisco mcp-scanner Snyk Agent Scan (fka Invariant Labs mcp-scan) License MIT Apache 2.0 source-available on GitHub; requires Snyk account/token to run Install zero dependencies, single Python file or pip install / npx github:... uv tool install , Python 3.11+ uvx snyk-agent-scan or standalone binary Signup / API key required to run at all No ( --demo needs nothing; scanning your own endpoint needs only your own endpoint's key) No (core YARA/static scanning works with zero keys; LLM/Cisco AI Defense/VirusTotal analyzers are opt-in extras) Yes — Snyk account + SNYK_TOKEN required before any scan runs What it scans Live LLM endpoint (prompt-injection/jailbreak suite) and static MCP tool manifests ( mcp.json ) Live MCP se

Small language models can now run directly on phones. But most of them stop learning the moment they ship. For personal AI, that feels like a strange stopping point. Some of the most useful signals arrive only after the model acts: Did the user dismiss the notification? Did they open it later? Did they rewrite the suggestion? Did they ask for it again? These interactions contain useful information about the user, but they are delayed, private, and ambiguous. They are not clean labels, and they are not reliable scalar rewards. To explore this problem, we built Online-SDFT , an open-source prototype that continually fine-tunes a small language model from delayed interactions while keeping the learning loop on the device. The prototype uses: LiquidAI/LFM2.5-230M A rank-4 LoRA adapter ONNX Runtime Training A bounded on-device replay buffer An Android notification-routing testbed Once the model has been provisioned, inference, interaction storage, replay, and adapter updates all happen locally. Why standard fine-tuning is awkward here Suppose the model receives a notification and chooses one of three actions: Show it now Save it for later Archive it Supervised fine-tuning would require a correct action for every notification. But the phone never observes what the ideal action was. Reinforcement learning replaces the correct answer with a reward, but that reward is also difficult to define. Opening a notification does not necessarily mean it arrived at the right time. Ignoring it does not necessarily mean it was unimportant. The user may simply have been busy. There is another complication: the model only observes the result of the action it actually took. If it archives a notification, it cannot know what would have happened had it shown the notification immediately. What the phone receives is not a label or reward. It receives hindsight . Using the same model as student and teacher The core idea is simple: let the model reconsider its decision after seeing what happened

Electric-vehicle assistants rarely have just one job. A short Turkish question may ask for a nearby station, a charging-price comparison, help planning a route, or an explanation of battery health. Before an application can retrieve current data or generate an answer, it needs to identify that intent reliably. We created the Turkish EV Charging Intent Dataset as a small, transparent starting point for that routing problem. Version 1.0.0 contains 192 Turkish queries distributed evenly across eight intent classes. It is open under CC BY 4.0, includes fixed train, validation, and test splits, and is maintained by TekPedal , an EV charging map and vehicle decision platform for Türkiye. You can explore the dataset interactively , inspect the source and validation workflow on GitHub , or cite the permanent Zenodo release with DOI 10.5281/zenodo.22062688 . Why intent routing comes first An assistant should not answer every EV question in the same way. Different requests need different tools and freshness guarantees: a station request needs a map or location index; a price request needs current tariff data; route planning needs distance, range, and charging-stop logic; a battery question needs careful educational content; a vehicle comparison needs structured specifications. An intent router makes that separation explicit. It can send each query to the correct retrieval source, product page, or application workflow. This also makes evaluation easier: teams can test routing independently before measuring the quality of downstream answers. Dataset design The taxonomy contains eight balanced classes, with 24 records in each class: FIND_STATION COMPARE_PRICE ROUTE_PLANNING CHARGING_SPEED VEHICLE_COMPARISON HOME_CHARGING BATTERY_HEALTH OWNERSHIP_COST Every record includes a stable ID, the Turkish query, the intent identifier, a human-readable Turkish label, a suggested TekPedal content route, the assigned split, the language, and a provenance marker. Here is a simplified example

Quick one: if PyRIT (Microsoft's Python Risk Identification Tool) is on your shortlist for LLM red-teaming, check the repo first. Azure/PyRIT was archived on GitHub on March 27, 2026. It's read-only now: no commits, no releases, no issue triage, nothing. Whatever version you pip-installed is the last version you'll ever get. That matters more for PyRIT than it would for most tools, because PyRIT was never a turnkey scanner. It's a framework for scripting multi-turn attack orchestration, the kind of thing a red team builds custom attack sequences on top of. A framework that's stopped shipping fixes is a worse foundation to build on than a finished tool that's stopped shipping features, because you were relying on it staying flexible to your needs, and now it can't. So what do you use instead? Depends on what you were actually using PyRIT for: You wanted a broad, actively maintained app-layer scanner -> promptfoo . Zero-install via npx promptfoo , 50+ red-team plugins, OWASP/NIST/MITRE ATLAS report mappings, and it's still getting regular releases. You wanted model-layer testing (jailbreaks, encoding tricks, data leakage on the base model itself, not your app) -> garak . NVIDIA-maintained, pip installable, 8k+ stars, actively developed. You wanted OWASP-mapped detectors and don't mind a paid tier for continuous scanning -> Giskard . The open source scanner is real and current; the always-on Hub is commercial. You wanted a fast, zero-setup smoke test before reaching for any of the above -> that's the gap we built sentinel-scan-cli for. Dependency-free CLI (Python and npm ports, identical output), 15 attack patterns each tagged to its OWASP LLM Top 10 category, --demo runs with no config and no API keys in under a minute. None of these replace PyRIT's specific multi-turn orchestration model one-for-one, if that's genuinely what you need, Microsoft's PyRIT Community fork discussion or building your own harness on top of a maintained model API is probably the honest answe

When Satoshi Nakamoto designed Bitcoin's Proof-of-Work consensus, the goal was simple: one CPU, one vote. What actually happened was very different. ASIC farms centralized mining into industrial warehouses, and the "one CPU" vision became "one warehouse, one vote." Proof-of-Stake was supposed to fix this by replacing energy expenditure with economic stake. Instead, it created a different problem: the rich get richer, forever. RustChain's Proof-of-Antiquity (PoA) takes a radically different approach. Instead of rewarding who has the most money or the newest hardware, it rewards who has kept the oldest hardware running the longest. The core insight is elegant: time is the one resource that can't be bought, faked, or manufactured. Either your hardware has been alive for twenty years, or it hasn't. This article does a deep technical comparison of Proof-of-Antiquity and Proof-of-Stake, drawing on the actual RustChain source code to explain how each consensus mechanism handles decentralization, Sybil resistance, economic fairness, and network security. The Fundamental Philosophies Proof-of-Stake: Wealth as Security Proof-of-Stake systems — Ethereum 2.0, Cardano, Algorand, Solana (with its Delegated PoS variant) — all share a common assumption: the more tokens you stake, the more committed you are to network security. If you act maliciously, your stake gets slashed. The economic logic is straightforward: attackers would need to acquire a majority of the token supply, which would be prohibitively expensive. The problem is what happens after someone acquires that stake. In PoS, staking rewards compound. A validator with 10x the stake of a small holder earns 10x the rewards, which they can reinvest into more stake. Over time, validator concentration increases. On Ethereum, Lido + Coinbase + Binance + Kraken collectively control over 50% of staked ETH. The "rich get richer" dynamic isn't a bug — it's a mathematical inevitability of proportional rewards based on capital. Proof-

I made a small Vim 9.2+ plugin called thumb . Put the cursor on an image path → :Thumb → popup the image. Select LaTeX in Visual mode → :Thumb → render it as an image popup. For example:  Put the cursor on diagram.png and run: : Thumb Or select: \frac { a }{ b } = \sqrt { x ^ 2 + y ^ 2 } and run: : Thumb It uses Vim's native popup image support, with Python/Pillow for image conversion and matplotlib for LaTeX rendering. No mappings are installed, so you can add your own: nnoremap < leader > t < Cmd > Thumb < CR > xnoremap < leader > t < Cmd > Thumb < CR > GitHub: https://github.com/JosefAlbers/thumb Requires Vim 9.2+, Python 3, Pillow, and matplotlib. Feedback welcome, particularly around the popup positioning/rendering.

Voice and chat assistants for the home share a deceptively hard job: turning messy natural language into precise, structured commands. “Make it cozy in here” has to become a concrete intent plus the right slots — which device, which room, which value. Domux is an open model from iFlytek that focuses on exactly this problem: command understanding for smart-home assistants, framed as intent parsing and slot filling. What it is Task: smart-home command understanding — intent parsing + slot filling Base model: fine-tuned on google/gemma-4-E2B-it Modality: multimodal (image + text input) Target: edge / on-device deployment rather than large cloud models License: Gemma Why the compact base matters Building on the small Gemma-4-E2B base keeps Domux in a size class meant to run close to the device. For home assistants, that direction is attractive: keeping command understanding on-device can reduce round-trips and keep more interaction local, instead of routing every utterance to a large hosted model. Try it The model card is on Hugging Face (access is gated — you may need to log in and request access): 👉 https://huggingface.co/iFlytekOpenSource/Domux We're sharing open work like this because on-device, task-focused models are a practical piece of the foundation-model and serving story — not everything needs to be a giant cloud model.