标签：#pens

TrustGraph 2.8 is available now, with a major upgrade to the platform foundation for enterprise knowledge and AI systems. This release focuses on a practical problem: AI applications must remain reliable when they grow beyond a single demo, a single document library, or a small number of workspaces. That means scalable messaging, dependable retrieval, typed model outputs, observable services, auditable decisions, and an interface that can adapt to different domains. Async pub/sub: removing a scaling bottleneck TrustGraph has completed its migration from thread-per-consumer pub/sub to an asynchronous architecture. In the previous model, a deployment with many workspaces and flows could consume hundreds of threads. TrustGraph 2.8 replaces that design with configurable async receive and send pools. Async support now covers: Apache Pulsar through pulsar.asyncio.Client RabbitMQ through aio-pika Kafka through aiokafka The API gateway and reverse gateway For operators, this means a much stronger basis for multi-workspace deployments. For custom processor developers, it also means migrating extensions to the async model. Hybrid retrieval for Document RAG Document RAG now combines two complementary retrieval strategies: Vector similarity for conceptual relevance. BM25 keyword retrieval for exact terms, names, identifiers, and domain-specific phrases. TrustGraph merges the results with Reciprocal Rank Fusion (RRF). The first keyword-index implementation uses SQLite FTS5 and scopes indexes by workspace and collection. If keyword retrieval is unavailable, TrustGraph degrades gracefully rather than blocking retrieval entirely. Hybrid retrieval is especially useful for enterprise content, where a user might search semantically in one query and need an exact product code, legal term, technical error, or named entity in the next. Native structured LLM output TrustGraph 2.8 carries JSON schemas from prompt definitions through the completion layer into provider-native structured-outp

GitHub热门项目 | 🦀 Small exercises to get you used to reading and writing Rust code! | Stars: 64,089 | 30 stars today | 语言: Rust

GitHub热门项目 | Stateful API logic for agentic applications using vLLM | Stars: 226 | 25 stars today | 语言: Rust

GitHub热门项目 | Durable, searchable memory of your past agent sessions. | Stars: 305 | 48 stars today | 语言: Rust

GitHub热门项目 | Trigram-indexed grep with a client/server architecture for fast regex search in large codebases locally | Stars: 1,658 | 1,353 stars today | 语言: Rust

GitHub热门项目 | 插件化、定制化、无广告的免费音乐播放器 | Stars: 26,707 | 49 stars today | 语言: TypeScript

GitHub热门项目 | Open-source SEO, GEO, and marketing skills for AI agents. | Stars: 3,665 | 51 stars today | 语言: TypeScript

GitHub热门项目 | 📱 Display and control your Android device graphically with scrcpy. | Stars: 11,203 | 173 stars today | 语言: JavaScript

Disclosure: I work on ESCPost and Receiptful, both mentioned below. ESCPost is Apache-2.0 and needs no account, so you can check every claim here yourself. If you have ever wired up a thermal printer, you know the loop: Move a column. Print. Squint at 58mm of paper. The total is off, or the euro sign came out as ? . Go back to 1. Every round costs paper, a walk to the printer, and about ninety seconds. And when it comes out wrong, you still do not know why. You never see the bytes. Two things fixed this for me. Both run on your machine, and neither needs a printer plugged in. They are part of ESCPost , our open-source Rust CLI. Apache-2.0, no account, works offline. Draw the bytes on screen ESC/POS is just bytes. If you know the printer's geometry, you can draw them on screen instead of on paper. escpost render receipt.hex --profile REFERENCE --output-dir renderings Logo, header, item columns, a double-height total, then a voucher with a QR code. It is drawn at the printer's own dot resolution, so the spacing you see is the spacing you get. Two files came out because the job has a cut in it. You get one PNG per sheet plus a manifest listing them. It reads stdin too: generate-receipt | escpost render - --profile REFERENCE > receipt.png Now your receipt code has a visual test. Three seconds a round instead of ninety. And since the render is deterministic, you can commit those PNGs and diff them in CI. That catches the refactor that shifted your tax column, before it reaches two hundred shops. Become the printer Most of the time the interesting bytes come from software you did not write. An ERP, a POS suite, some legacy Windows thing. You cannot see what it sends. Nearly all of them print over RAW TCP on port 9100. So pretend to be the printer: escpost serve --listen 127.0.0.1:9100 --web-listen 127.0.0.1:9000 --profile REFERENCE Point the application at that address and hit print. Nothing reaches paper. The job opens in your browser instead. Sheets on one side, the dec

Introduction One morning, while going through the latest batch of Postgres commits, I saw this : commit bd8d9c9bdfa0c2168bb37edca6fa88168cacbbaa Author: Heikki Linnakangas heikki.linnakangas@iki.fi Date: Tue Dec 9 13:53:03 2025 +0200 Widen MultiXactOffset to 64 bits This eliminates MultiXactOffset wraparound and the 2^32 limit on the total number of multixid members. Multixids are still limited to 2^31, but this is a nice improvement because 'members' can grow much faster than the number of multixids. On such systems, you can now run longer before hitting hard limits or triggering anti-wraparound vacuums. Just like that, quietly and almost routinely, Postgres moved past one of its annoying limits: the cap on the number of transactions in a multitransaction is now history. Formally, yes, it is now limited by an 8-byte unsigned integer, but that number is so massive that I can’t imagine it being exhausted anytime in the foreseeable future. When you spend years working on something and it finally gets done, it’s hard to believe it’s really over. There was always a small chance the community could still roll the commit back. Now that almost three months have passed (and the commit seems to have settled in), I want to share my thoughts as a direct participant in these events and the patch author. Three juggling brothers In Postgres, there are three bottlenecks tied to 32-bit counters: transaction identifiers, also known as xid or “xids”; multitransaction identifiers, also known as mxid; multitransaction offsets. Users rarely notice this one, but under the wrong conditions, it can become quite nasty. More on that later. It’s worth noting that each of these counters can “wrap around,” meaning they handle overflow normally, and this does not crash the database or cause data loss. Depending on your workload and database size, you might not even notice that, say, after 4 billion, the transaction counter has become 1073. Any of these counters can become a problem, or not. Each

By Jordan Massiah, MTS @ Trent AI A couple of months ago we released the OpenClaw Security Assessment Skill (trentclaw), an agent that audits ClawHub skills for vulnerabilities and malicious behavior. Since then several new scanners have shipped, including NVIDIA's SkillSpector and ClawHub's own updated tooling. We wanted to see how the scanners actually compare. This matters because ClawHub is open. Anyone can upload a skill, and over 60K are now live. Many carry vulnerabilities; some are outright malicious. In February 2026, the ClawHavoc campaign planted malicious skills that posed as productivity tools while exfiltrating API keys, SSH credentials, and browser data. When an agent installs one, it inherits whatever that skill does. So we built an expert-labelled set of 60 ClawHub skills and benchmarked five scanners on the 54 that all of them can run. Three things stood out: The agent-based scanner (trentclaw) caught 94.6% of potentially dangerous skills, the only scanner above 60%. The next best caught about half (54.1%) and the rest caught under 40%. How much a scanner catches depends on how much it reasons, not just how many patterns it matches. Signature and static scanners catch as little as 8.1%. A single LLM pass does better but still misses about half. The hardest skills to catch ship no code at all. That is the main reason for the recall gap. Benchmark setup The corpus is 60 OpenClaw skills, manually labelled into three balanced categories of 20: benign, vulnerable, and malicious. For the cross-scanner comparison we collapse vulnerable and malicious into a single flagged class, and score the 54-skill intersection every scanner can process. The five scanners: Trent's OpenClaw Security Assessment Skill (trentclaw), VirusTotal Code Insight, ClawScan (legacy standalone), ClawHub static analysis (~30 regex/AST rules), and NVIDIA SkillSpector. Snapshot dates: ClawHub scanners May 7, 2026; SkillSpector Hugging Face data June 1, 2026. How the scanners compare The

Most “lightweight” forums cut corners. FlatBB is different: plain PHP 8.1+, no Composer/Docker/build step — but the feature list is what small communities actually need. Built-in languages Interface packs ship in the box: English, German, French, Spanish, Portuguese, Italian, Dutch Persian (فارسی) with full RTL layout mirroring Also: Header globe language switcher (remembered for visitors; members can set Preferences) Admin default language Per-visitor time zones for displayed times; site timezone for email/feeds/logs Post text follows its own writing direction (mixed-language communities work) Core features Discussion: nested categories (one level) + per-group permissions, tags, topics/replies, quotes, @mentions, Markdown + live preview, drag/paste image upload, likes, bookmarks, unread tracking, notifications. Discovery: full-text search (SQLite FTS5 / MySQL FULLTEXT), Latest / Top / Unread, clean URLs, RSS, sitemap, profiles & avatars. UX: Discourse/Flarum-style three-column layout that collapses on phones, dark mode, one-click upgrades. Admin: settings, categories, tags, users, groups, layout blocks, plugins, scheduled jobs, tools. Need more? The marketplace and AI-friendly plugin API cover SEO, social login (Google/GitHub/X), Q&A, levels, verified badges, Guard/2FA, drafts, and more. Plugin docs for assistants: https://www.flatbb.com/dev/plugins.md Links Site: https://www.flatbb.com/ Download: https://www.flatbb.com/download GitHub: https://github.com/nwnuyhs/flatbb Marketplace: https://www.flatbb.com/market MIT licensed. If you try it, tell us where it breaks — the support forum runs on FlatBB itself.

Introduction Modern AI systems rarely rely on a single model anymore. A fraud detection pipeline might combine specialists for: Transaction analysis Identity verification Device fingerprinting Network analysis Similarly, RAG pipelines, LangGraph workflows, and other multi-agent systems often have several AI agents collaborating before producing a final decision. As these systems become more complex, one question becomes surprisingly difficult to answer: Which agent actually influenced the final decision? Running four or five agents doesn't necessarily mean all of them contributed. Sometimes a single specialist completely determines the outcome while the rest simply add latency and compute cost. Most multi-agent frameworks make it easy to build agent workflows—but they don't tell you which agents actually mattered . That question led me to build agent-ablation , a lightweight TypeScript library for performing leave-one-out ablation testing on multi-agent decision systems. Why I built this While experimenting with multi-agent systems, I kept asking myself questions like: Which specialist actually changed the final verdict? Which agents consistently influence decisions? Are some agents effectively redundant? Am I paying for LLM calls that never affect the outcome? Answering those questions usually meant manually removing agents, rerunning experiments, and comparing outputs. That quickly became tedious. I wanted a simple utility that could automate this experiment. Instead of guessing which agents mattered, I wanted to measure their influence. That's why I built agent-ablation . The Idea The core algorithm is intentionally simple. Given a set of agent findings and a deterministic decision function: Compute the baseline decision. Remove one agent's finding. Recompute the decision. Compare the new verdict with the baseline. Repeat for every agent. If removing an agent changes the verdict, that agent is load-bearing . Otherwise, it wasn't necessary for producing that parti

Agents can already talk. MCP and A2A exist. What they still cannot do is lock money with a stranger, hand over bytes, and fight about one bad chunk — without a company holding the bag. That gap is what ArthNeura is for. Two repos on purpose arthneura-core is a Substrate solo-chain. pallet-agent-registry — ML-DSA-65 DID, deposit, reputation pallet-vector-db — Merkle commitment, dispute bound to one chunk index pallet-escrow — lock / release / refund Pallets do not import each other. The runtime wires traits. arthneura-market is only discovery. Listings, signed offers, delivery URLs. No keys. No funds. No verdict. The board names the next chain call and does not submit it. Status Pre-testnet. v0.1. Local --dev node. Not a public network. Not a token post. https://github.com/arthneura/arthneura-core https://github.com/arthneura/arthneura-market https://github.com/arthneura

“Store the data” is only the beginning of the problem. The difficult questions usually come afterward: What structure does this data actually have? Which fields are missing or inconsistent? Which values are invalid? Which changes are safe to apply automatically? What exactly changed after a repair? Can the system prove that its storage and indexes are still consistent? I built Atlas to answer those questions inside the database engine itself. Atlas is a zero-dependency embedded database for semi-structured data. It stores records, builds a full-text search index, infers schema, analyzes data quality, proposes safe repairs, preserves uncertain records, and records an audit trail of applied changes. It does not use SQLite or SQL. It is not intended to replace SQLite for relational workloads. Instead, Atlas focuses on a gap that is usually handled by external scripts and tools: Data inspection, diagnosis, and safe repair as first-class database capabilities. That is the problem Atlas was built to solve. Why data quality belongs inside the database engine Most databases are very good at storing and retrieving data. That is necessary, but real-world data work rarely stops there.** Operational records, imported JSON, CSV files, event payloads, and semi-structured documents often arrive with problems: { "id" : "T-1" , "title" : " Connection timeout " , "priority" : "HIGH" } { "id" : "T-1" , "title" : "connection timeout" , "priority" : "high" } { "id" : "T-2" , "title" : "Unicode café search" , "priority" : null } These records contain several potential issues: Duplicate logical identifiers Leading or trailing whitespace Inconsistent capitalization Null-like values Missing fields Mixed data types Malformed email addresses Different date formats Inconsistent structures across records A storage engine can preserve these values perfectly while still leaving the data difficult to understand and use. The usual response is to add external tools: A schema profiler A data-quality

Somewhere in the DataLens build, my teammate and I hit the wall every "zero-dependency" project eventually hits: the anomaly detector needed a neural net, and the rulebook said no third-party packages. No NumPy. No pandas. No scikit-learn. Just Python 3.14's standard library. Our first reaction was denial. You cannot build an ANN without a matrix library — everyone knows that. numpy.dot() is basically load-bearing infrastructure for machine learning in Python. We spent an embarrassing amount of time trying to convince ourselves some obscure math submodule secretly did vectorized linear algebra. It doesn't. There is no shortcut. If you want matrix multiplication in pure stdlib Python, you write nested for loops and you like it. What we normally would have installed In any other project, this is a two-second decision: pip install numpy , import it, move on with your life. Matrix ops, broadcasting, vectorized activation functions — all free. Neither of us had ever really had to think about how A @ B works under the hood, because neither of us had ever had to write it ourselves. What it actually took to replace it An autoencoder needs: matrix multiplication, transpose, element-wise activation functions (sigmoid, ReLU), and gradient computation for backprop. Without NumPy, every one of those is a hand-rolled function operating on nested Python lists. Matrix multiply becomes three nested loops instead of one line. A forward pass that would be a single .dot() call turns into a small file of helper functions: matmul() , transpose() , add_bias() , sigmoid() , sigmoid_derivative() . We split it — one of us built the forward pass and activation functions, the other took backprop and the training loop — and then spent a good while debugging the seam where the two met. The genuinely hard part wasn't the math — it was performance. Pure Python loops over lists of lists are slow, and profiling a dataset with a few thousand rows through even a small autoencoder made that obvious fas

Angular has changed in recent versions, especially around how developers handle reactive state....

💻 One thing I dislike about coding-agent setups is how quickly they become part of one specific machine. Provider config goes in one place, session state somewhere else, local models live in another directory, and suddenly moving to a second machine means rebuilding the environment. OpenClaude-Portable takes a much cleaner approach. It packages the coding agent, runtime and persistent data into a self-contained folder. It supports cloud and local models in the same setup The project currently supports 9 provider options: Anthropic Claude OpenAI Google Gemini DeepSeek OpenRouter NVIDIA NIM Ollama LM Studio custom OpenAI-compatible APIs I like this because the portable part is not tied to one model vendor. I can use a cloud model when I want the strongest hosted option, then switch to Ollama or LM Studio when I want a local workflow. The important caveat is simple: cloud providers still need internet. Ollama can run offline after the initial setup. The "zero footprint" idea is more useful than it sounds The project redirects its persistent data into a local data folder. That includes provider settings, API keys, logs, session history, agent memory and local Ollama files. According to the repository, it does not write configuration into the host system. For me, this is the real feature. I do not care that the agent happens to be on a USB drive. I care that I can move the folder and keep my environment with it. 💾 There are two very different ways to run the agent The launcher offers a normal mode that asks before file writes or shell commands. There is also an optional Limitless mode that can run without approval prompts. I like that these are explicit choices rather than one hidden permission switch. For normal development I would keep approval mode on. For a disposable test project or a controlled autonomous task, the second mode could be useful. Sessions can survive the move Another practical detail is session resume. The project stores session history inside the por

Faker Doesn't Know Your Entities Are Related, So I Built Something That Does You've added a second entity to the schema, wired up a @ManyToOne , and gone back to your seed script to generate fifty more rows. Ninety seconds later, the app refuses to start: unique constraint violation, somewhere inside a loop you wrote three weeks ago at 11pm. You fix it. You restart. A different field breaks a different constraint. This is the exact moment every Spring Boot developer eventually meets the real limit of tools like Faker. They're brilliant at generating a name, an email, an address. They have no idea the Payment sitting in front of them needs a Counterparty to already exist. So you do what everyone does: hand-write the wiring. Create parents first. Hold onto their generated IDs. Wire them into children. Hope you didn't just violate a @NotNull somewhere in the process. It works, for a while. Then the schema changes, and the script quietly stops matching reality until the next 3am debugging session finds out the hard way. I hit this enough times that I stopped patching the script and looked at the actual problem: the information needed to seed this correctly already exists. It's sitting right there in the entity, in the annotations you already wrote. @ManyToOne , @NotNull , @Column(unique = true) , JPA already knows the shape of your data. Nothing should need to be told that twice. That became SynthForge . The core idea Instead of writing a script that generates data, you annotate the entity: @Entity @Seed ( count = 50 ) public class Counterparty { /* fields only */ } @Entity @Seed ( count = 200 ) public class Payment { @ManyToOne ( optional = false ) private Counterparty counterparty ; } Start the app in a dev profile. Both tables populate, correctly ordered, on every restart. No seed method. No calling code, anywhere. The entity is the seed script. What's actually happening underneath Entity scanning. SynthForge reads JPA-managed attributes through the jakarta.persisten

An approval rule becomes useful when you can test what happens on both sides of it: the forbidden action is refused, and the permitted decision leaves evidence. A happy-path demo alone cannot show that distinction. Here is a runnable example using Accordo, the open-source framework coding agents use to build custom CRMs. A synthetic customer wants 30 seats of an Enterprise Plan and requests 25% off. The existing policy permits automatic approval through 10%; above that, through 50%, it requires a user decision. Run it locally You need Git, Node.js 22.16 or newer, npm, and internet access for cloning and dependency installation. Start in an empty working directory: git clone https://github.com/khaoss85/agent-crm.git framework-source cd framework-source git checkout 3b5b5f0c4c3e582e48d54501136024b064756daa node --no-warnings examples/recipes/quote-approval/run.mjs ../my-quote-crm The pinned recipe source creates a project, installs its dependencies and composes the existing commercial package. It then starts a temporary server on localhost and drives the public SDK through HTTP. The catalog is a fixture; the business journey does not call an external provider. It uses source from the checkout, independently of the npm scaffolder release. Check the refusal, then the decision The script contains assertions for each transition: Server pricing produces EUR 3,750 once and EUR 2,400 per month after discount. These are synthetic quote amounts, kept in separate periods. Submission under policy version 1 freezes a commercial snapshot and enters pending_approval . An approval request from the simulated agent receives HTTP 403 with HUMAN_APPROVAL_REQUIRED . The quote and approval remain pending, and no business audit entry is added. A simulated user approves. The quote becomes approved , with one user decision audit and a completed trace. The submitted snapshot remains unchanged. There is one quote version and one approval record. The refusal also has a failed trace. That is a u