标签：#pens

Certification prep often stops at notes and multiple-choice questions. Copilot Studio makes more sense once you actually build something. So I added a free AB-620 hands-on lab to Examplar. It covers creating an agent, writing clear instructions, testing in-scope and out-of-scope prompts, publishing it, and cleaning up afterwards. Each step includes something learners can check before moving on. The public Preview also has 25 original practice questions. No exam dumps. Examplar is my independent, open-source side project. The Preview and lab are free, and the page also links to optional paid packs. Try the free lab: https://examplar.app/exams/ab620/#labs-h Blunt feedback is welcome. Which hands-on scenario should I add next?

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback. Okay so here's a fun one for you. Imagine you invent the thing that eventually becomes the substrate for Google, Facebook, Amazon, your bank, your ex's Instagram, and every cursed cookie consent banner known to man. Now imagine you had the legal right to charge a licensing fee for it. Like, a reasonable one. A cent per page load, say. You would never have to work again. Your great-great-grandchildren would never have to work again. You'd be sipping something expensive on a boat named after a HTTP status code. Tim Berners-Lee looked at that exact opportunity in 1993 and said, essentially, "nah, you guys keep it." This has been rattling around in my head for days, so let's talk about it properly, with all the nerdy details. The web almost lost to a gopher (literally) Berners-Lee built the World Wide Web in 1989 at CERN, laid out in a proposal called Information Management: A Proposal , mostly so physicists could stop emailing each other giant papers and just... link to things. Wild concept, I know. But here's the part people forget: the Web wasn't the obvious winner in the early 90s. It had a genuine rival called Gopher , built at the University of Minnesota, and for a while Gopher was winning. It was simpler, it was faster on the slow modems of the era, and it had a head start in adoption among universities and libraries. Then in February 1993, the University of Minnesota did something that, in hindsight, ranks among the great unforced errors in computing history: they announced they'd start charging licensing fees for commercial use of Gopher server software. Reasonable-sounding at the time (they needed to fund development), catastrophic in practice. The developer community, which had spent years contributing code for free on the assumption

GitHub热门项目 | 29 editorial diagram types for Claude Code. Self-contained HTML + SVG. No shadows, no Mermaid-slop. | Stars: 6,003 | 1,612 stars today | 语言: HTML

I Benchmarked Two Local LLMs on Real Dev Work — Qwopus 27B vs Muse Glimmer 30B Two open-weight models, one 20 GB GPU, two real development tasks, and a third model as the referee. Here is what actually happened when I made Qwopus 3.6 27B and Meta's Muse Glimmer 30B implement a bug fix and then a full feature in my own project. The setup Both models ran fully local on an AMD Radeon RX 7900 XT (20 GB VRAM) via a llama.cpp multi-model router (one OpenAI-compatible endpoint, GGUF models, load-mode=dio — more on why below). Each model was driven by the pi CLI in non-interactive mode with --thinking high . A third model — Codex, through a disciplined stdin wrapper — reviewed both outputs and gave the verdict. The fairness method was simple but strict: One task , described in a markdown spec, copied byte-identical into two isolated git clones of my project. Each model worked in its own clone, its own branch , never seeing the other's work. Objective verification by script: existing test suite + new tests + production build. Cross-review by Codex , examining both branches against the same criteria. The test project: Jeu de Cochons (a "Pass the Pigs" dice game, vanilla JS PWA on Vite + Vitest) — real code, real tests, no toy repo. Qwopus 3.6 27B Muse Glimmer 30B Source Community fine-tune of Qwen 3.6 Meta (distilled from Muse Spark) Size 27B 29.6B Quant IQ4_XS (~15 GB) UD-Q4_K_XL (~14.8 GB) Round 1 — fixing a regression (short task) The project had a broken PWA: a commit that added a /jeu-de-cochons/ base path for GitHub Pages had broken 3 service-worker tests (manifest, precache, offline navigation fallback). Task: fix the regression without touching the tests , keep the other 84 green. Qwopus Muse PWA tests (11) 11/11 ✅ 11/11 ✅ Full suite (87) 87/87 ✅ 87/87 ✅ Files touched 2 2 Diff size +4/−4 +4/−4 Wall time ~8.5 min ~21 min Leftover artifacts none one .bak file The remarkable result: both models produced a byte-identical diff. Same diagnosis (a lost capture group in the a

The first collaboration model in CodeVerse was convincing in exactly the way a local demo needs to be convincing. Open two tabs. Join the same room. Type in one editor. Watch the other editor update. Then ask one unpleasant question: what happens when those two sockets land on different server instances? The answer was that the room stopped being a room. Each process had its own memory, its own presence list, and its own idea of the current files. A restart erased state. A reconnect could create a second identity. A load balancer could turn a working demo into two isolated conversations. This article is about the work that followed: moving CodeVerse from synchronized tabs to a collaboration path I could test across processes, recover after disconnects, and describe without pretending a local benchmark was a production capacity claim. The real boundary was not Socket.IO Socket.IO made connection handling and room fan-out approachable, but it did not decide where truth lived. That distinction matters. A room name inside one Socket.IO process is a routing convenience, not durable shared state. Once I wanted multiple application instances, I needed separate answers for four kinds of information: Document state — the convergent contents of every file. Room policy — organizer identity, edit permissions, active file, and revision. Presence — which sockets are here now, on which instance, with which effective role. Durability — what survives Redis expiry, application restarts, or a longer period of inactivity. CodeVerse now uses Yjs for convergent document updates, Redis for live distributed room state and pub/sub, and Supabase for durable room snapshots and membership data. Socket.IO remains the transport and fan-out layer. That separation was more important than any individual library choice. Redis does three different jobs It is easy to say “I added Redis” and leave the architecture vague. In CodeVerse, Redis has three explicit responsibilities. 1. Cross-instance fan-out

GitHub热门项目 | Rivet Actors are the primitive for stateful workloads. Built for AI agents, collaborative apps, and durable execution. | Stars: 5,998 | 197 stars this week | 语言: Rust

GitHub热门项目 | Cross-platform & feature rich iOS/iPadOS/tvOS sideloading application. Formerly known as PlumeImpactor. | Stars: 2,915 | 19 stars today | 语言: Rust

GitHub热门项目 | Send files from one device to many in real-time. | Stars: 1,468 | 26 stars today | 语言: JavaScript

GitHub热门项目 | Breakthrough Method for Agile Ai Driven Development | Stars: 51,759 | 46 stars today | 语言: JavaScript

GitHub热门项目 | A clean, self-hosted web UI for managing your Traefik reverse proxy. | Stars: 1,207 | 31 stars today | 语言: JavaScript

GitHub热门项目 | 🤗 Transformers: the model-definition framework for state-of-the-art machine learning models in text, vision, audio, and multimodal models, for both inference and training. | Stars: 163,607 | 69 stars today | 语言: Python

GitHub热门项目 | Node Version Manager - POSIX-compliant bash script to manage multiple active node.js versions | Stars: 94,417 | 18 stars today | 语言: Shell

The fourth in a suite of deterministic MCP servers for AI agents — and the one that ties the first three together. Over the last stretch I shipped three focused, deterministic MCP servers: ScenarioSim — what-if / scenario simulation DecisionMatrix — multi-criteria decision analysis PrecisionCalc — exact finance / business math They're great on their own, but agents kept needing all three in the same task — and installing three servers, juggling three keys, and hand-gluing their outputs is friction. So here's AgentStack MCP : one endpoint, one key, all three — plus composite tools that chain them. simulate → decide → compute { "mcpServers" : { "agentstack" : { "type" : "http" , "url" : "https://agentstack-mcp.pages.dev/mcp" } } } Free tier: no key, 20 calls/day. The tools are namespaced so an agent always knows which engine it's calling: sim_* — ScenarioSim (run, sensitivity, break-even, compare, templates) decide_* — DecisionMatrix (decide, score, sensitivity, compare_two, methods) calc_* — PrecisionCalc (metrics, currency, NPV, IRR, loan, depreciation, …) The part that's actually new: composite tools These chain the engines to do reasoning no single server can , deterministically end-to-end: evaluate_options_with_scenarios (simulate → decide) — project each option as its own scenario, then rank the outcomes against weighted criteria: { "name" : "evaluate_options_with_scenarios" , "arguments" : { "template" : "saas_growth" , "horizon" : 12 , "options" : [ { "name" : "Aggressive" , "inputs" : { "new_customers_per_period" : 60 , "churn_rate" : 0.05 } }, { "name" : "Lean" , "inputs" : { "new_customers_per_period" : 20 , "churn_rate" : 0.02 } } ], "criteria" : [ { "metric" : "ending_mrr" , "weight" : 3 , "direction" : "benefit" }, { "metric" : "total_churned_customers" , "weight" : 1 , "direction" : "cost" } ] } } plan_to_valuation (simulate → compute) — project a plan, then value its cash-flow line: NPV, IRR, undiscounted total. stress_test_decision (simulate × decide)

TL;DR — Events in Fitz LiveViews carry data three ways: a click payload ( data-flv-value-* ) tags a button with the value it should send; a form submit ( data-flv-submit ) reads the form's named inputs; and a live value ( @input / @change ) delivers a control's current value in payload["value"] . All three land in the same place — a payload map your handler reads. This post builds a live name list (add / remove / count) that runs both server-rendered and as WebAssembly. (Part 3 of the FitzLiveViews series.) Parts 1 and 2 covered the pitch and the counter. A counter only reads +1 / -1 — no data flows in . Real UIs take input: text, selections, form fields. Here's how that data reaches your handlers. The payload Every event handler has a payload in scope — a Map<Str, Str> . The three mechanisms below all fill it; your handler reads it with payload["key"] (guard with payload.has("key") ): 1. Click payload — a button that carries a value Tag any element with data-flv-value-<key>="{expr}" , and when a data-flv-click on it (or an ancestor) fires, that value rides along: <button data-flv-click= "remove" data-flv-value-item= "{it}" > × </button> event remove () { if ( payload . has ( " item " )) { let target = payload [ " item " ] names = names . filter ( fn ( it ) => it != target ) } } The delete button knows which row it is because the row's value is stamped on it. No IDs threaded through a callback, no closure capture. 2. Form submit — the whole form at once data-flv-submit="handler" on a <form> reads each named input into the payload on submit; data-flv-clear resets a field afterward: <form data-flv-submit= "add" > <input name= "item" placeholder= "Add a name" data-flv-clear /> <button type= "submit" > Add </button> </form> event add () { if ( payload . has ( " item " )) { let n = payload [ " item " ] if ( n != "" ) { names . push ( n ) } } } payload["item"] is the input's value at submit time. No preventDefault , no FormData , no fetch . 3. Live value — @input / @chang

Introduction: The Enterprise AI Architecture Question Enterprise AI is entering a new phase. The first wave was about putting large language models into applications. The second wave focused on Retrieval-Augmented Generation (RAG), enterprise search, copilots, and AI assistants. Now, enterprises are asking a more fundamental question: What should the architecture behind enterprise AI actually look like? Should one powerful AI system receive a business problem, access the required tools, reason through the workflow, and deliver the answer? Or should the work be divided among multiple specialized AI agents—each responsible for a specific function—with an orchestrator coordinating the entire process? This is the debate between single-agent AI and multi-agent AI. And the answer is more nuanced than “more agents are better.” A single agent can be remarkably effective when the workflow is focused, sequential, and supported by the right tools and context. Multi-agent architectures become attractive when work can be decomposed into independent streams, when specialized expertise is required, or when the scale of the problem exceeds what one agent can efficiently manage. Recent research on agent architectures highlights exactly these trade-offs: capability versus reliability, autonomy versus controllability, and accuracy versus latency and cost. The real enterprise question, therefore, is not: “How many AI agents should we deploy?” It is: “What architecture best matches the complexity of the business problem?” What Is a Single-Agent AI Architecture? A single-agent architecture typically consists of one AI agent powered by a foundation model, connected to enterprise data, tools, APIs, memory, and business systems. The agent receives a goal and determines how to accomplish it. A simplified architecture looks like: User Request → AI Agent → Reasoning → Tools/Data → Action → Result For example, imagine an employee asks: “Why did yesterday's sales decline in the western region?”

While researching for this post, I found out something funny. Pi, the most interesting coding agent...

The concrete problem Running two or three coding-agent sessions is easy. Knowing when their work is safe to combine is not. One session changes an API while another writes regression tests against the old shape. A third investigates a production failure and quietly edits the same configuration file. Git worktrees prevent immediate filesystem collisions, but they do not explain task dependencies, transfer assumptions, or warn that two agents are solving incompatible versions of the problem. The developer becomes a human message bus: checking terminals, copying commit IDs, repeating context, and deciding which session should wait. The more capable each agent becomes, the less useful a wall of terminal panes is as a coordination interface. The current signal Claude Code now supports messaging between sessions on the same machine. Its documentation describes session discovery, plain-text messages, and a local messaging socket. Agent view separately exposes background-session state, worktrees, pull-request status, and a JSON listing suitable for scripts. Hooks can observe tool input and block a tool call before execution. That does not prove demand for a new product. It does create a concrete implementation moment: the primitives for handoffs and visibility exist, while dependency ownership and conflict negotiation remain a workflow problem. In RayTally's bounded Hacker News snapshot at August 9, 00:33 UTC, the cross-session messaging discussion had 50 points and 26 comments and ranked 18th. Those numbers describe that historical observation only; they are not user counts, market validation, or a prediction of lasting interest. A product direction: a control desk for handoffs The useful product is not another chat window. It is a small local control desk that makes each session declare four things: its goal, worktree, files it expects to touch, and the result another session is waiting for. When the API session finishes, the testing session should receive a compact hando

How We Built an IoT Platform That Handles 30 Million Concurrent Connections — With a Team of 10 DGIOT is an open-source industrial IoT platform. We run 928 gateways across 16 oil fields, process 652 million data points, and maintain 99.9999% uptime. Here's the architecture that makes it possible. The Problem In 2021, we got a call from Daqing Oil Field — China's largest oil producer. They had a problem: 928 industrial gateways from different vendors 114,809 sensor points speaking 15 different protocols Data collection every 10 minutes (they needed seconds) 15-30 minute end-to-end latency (they needed <3 seconds) False alarm rate above 20% The existing system was a patchwork of vendor-specific tools, each with its own database, UI, and authentication. Operators had to log into 8 different systems just to check if a pump was overheating. They asked: "Can you unify this?" What We Built DGIOT is an Erlang/OTP-based platform that acts as a universal translator for industrial protocols. Think of it as a Rosetta Stone for machines. Modbus ─┐ OPC UA ─┤ MQTT ──┼──→ Unified Pipeline ──→ TDengine ──→ Dashboard IEC104 ─┤ A11 ──┘ The key insight: industrial protocols are just state machines . Once you model each protocol as a gen_statem FSM in Erlang, you can handle hundreds of them concurrently with almost zero overhead. The Architecture: DLAS We designed a four-layer architecture that separates concerns cleanly: Layer 1: DATA — Ingestion Parse Server (23 classes) handles device metadata, user auth, tenant isolation TDengine stores 652M time-series data points with 10:1 compression EMQX handles MQTT message routing at 1M+ msg/sec Mnesia/ETS provides in-memory caching for hot data Layer 2: LOGIC — Ontology Engine This is our secret weapon. We built a 252-entity OWL ontology that models industrial equipment: Pump ⊑ Equipment ⊓ ∃ hasPart.Bearing ⊓ ∃ measures.Pressure Bearing ⊑ Component ⊓ ∃ hasFailureMode.Overheat Overheat → triggers ( Alert ) ∧ reduces ( RemainingLife , 0.8 ) The

Qarinah compiles a compact, cited project-memory pack instead of asking every new coding-agent session to replay the entire available history. The published estimate Across six committed software-task fixtures, the full-history baseline contained 442,113 portable estimated input-context tokens . The Qarinah path used 5,682 . Every required target was still directly covered in the top five results. That is: 436,431 fewer estimated input-context tokens; 98.71% less repeated context; and a 77.81:1 baseline-to-pack ratio. The ratio is not a claim that every provider bill drops by 98.71%, or that an agent session lasts 77.81 times longer. It measures the compared input-context volume in the published six-fixture estimate. What the same token rate would cost The table applies four flat, uncached input-token rates to the same two token estimates. It is arithmetic, not a provider invoice. Flat uncached input rate Full-history baseline Qarinah pack Estimated saving $1 / million tokens $0.442113 $0.005682 $0.436431 $3 / million tokens $1.326339 $0.017046 $1.309293 $5 / million tokens $2.210565 $0.028410 $2.182155 $15 / million tokens $6.631695 $0.085230 $6.546465 The calculation is: estimated tokens / 1,000,000 x flat input rate It deliberately excludes provider-native tokenization, caching, output tokens, reasoning tokens, tool calls, retrieval, hosting, and fixed fees. Real cost depends on the provider, model, cache behavior, context composition, and how often the same history would otherwise be resent. Why the pack remains useful Compression only matters if the next task can still find its evidence. The benchmark checks both volume and retrieval coverage: every required target had to be directly present in the top five. Qarinah preserves the source event ID and content hash for selected context, so a later agent receives a bounded handoff that can be inspected instead of an opaque story. Qarinah also passed 380 of 380 deterministic file-specific exact and typo-tolerant que

If you've ever needed to build a serious data table in React, you've probably run into this problem....