今日已更新 133 条资讯 | 累计 37990 条内容
关于我们

标签：#open

找到 2665 篇相关文章

AI 资讯

Node.js has plenty of circuit breakers. So why did I build another one?

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

2026-07-27 原文 →
AI 资讯

We Gave Our AI Agents Employee IDs. Here's Why

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

2026-07-27 原文 →
AI 资讯

Kimi K3 Is the Biggest Open-Weight Model Ever Shipped. Here's What Actually Matters.

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

2026-07-27 原文 →
AI 资讯

Octo: When AI Coding Gets 10x Faster, How We Designed for the Collaboration Gap

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

2026-07-27 原文 →
AI 资讯

I built a guard that refused to read the user's tab. Then my own cleanup code closed it.

Three days ago my browser automation tool closed one of my own tabs. Not a tab it had opened — a dashboard I had open in another window, with a page I hadn't finished reading. What makes it worth writing up isn't the bug. It's that the guard designed to prevent exactly this had already fired, correctly, ninety seconds earlier. The guard worked Safari MCP lets an AI agent drive your real, logged-in Safari. That premise means the single worst thing it can do is act on a tab you're using. So there's an identity system: every tab the tool opens gets a marker stamped into window.name , which survives navigation, redirects, and cross-origin loads. Before running anything in a tab, the tool checks the marker. I was filling in a form. The URL was a forms.gle shortlink, which 302s to docs.google.com — a cross-origin redirect that, it turns out, drops window.name . My next read came back refused: Tab tracking lost — refusing to target the user's current tab. Correct. Exactly the intended behaviour. The tool no longer knew which tab was its own, so it declined to guess. So I did the tidy thing and cleaned up my orphaned tab: safari_close_tab It closed a different tab. One of mine. The tool went from "I can't prove which tab is mine, so I won't read" to "let me close a tab" in one step, and nobody stopped it. The shape of the hole Here is the close path as it existed: if ( _st (). activeTabIndex ) { await osascript ( `... close tab ${ _st (). activeTabIndex } of ${ window } ` ); } else { await osascript ( `... close current tab of ${ window } ` ); // ← the user's tab } current tab of window is whatever the user is looking at. So the fallback for "I don't know which tab is mine" was "close theirs." That branch is only reachable when the index is unknown — which is precisely the state the guard had just announced. The two pieces of code were describing the same condition and disagreeing about what it meant. Three layers, one mistake When I went looking, the same fail-open was in

2026-07-27 原文 →
AI 资讯

I Built 47 Free Dev Tools That Run Entirely in Your Browser

Every developer has done it — copy-pasted a JWT, a private key, or a JSON blob with sensitive data into some random website and held their breath. Wondering if it was being logged, tracked, or worse. Every developer has done it — copy-pasted a JWT, a private key, or a JSON blob with sensitive data into some random website and held their breath. Wondering if it was being logged, tracked, or worse. I built KRUMB.DEV because I wanted tools that didn't make me feel dirty after using them. What Is It? 46 developer tools, all in one place. No signup. No uploads. No tracking. Open source. The terminal-inspired interface isn't just aesthetic — it's a constraint. Every tool fits in a single column, zero sidebar, zero popups. Just you and the tool. What's Inside Formatters — JSON, SQL (17 dialects), HTML, JavaScript, CSS Encoders — Base64, URL, JWT decoder, YAML↔JSON, JSON↔CSV Generators — Passwords, UUIDs (v1/v3/v4/v5), hashes (MD5/SHA/HMAC), QR codes, Lorem Ipsum, color palettes, CSS gradients/shadows/grids, meta tags, robots.txt, .gitignore Testing & Debugging — Regex tester, diff checker, webhook tester, cURL→code, HTTP status reference, cron expression builder Converters — Unix timestamps, hex↔RGB, binary, SVG→JSX, JSON→TypeScript, HTML playground, markdown editor Network — DNS lookup, SSL checker, IP lookup, QR code decoder, IBAN validator Why I Built It This Way Most "free" dev tools follow the same pattern: create an account, hit a rate limit, and wonder if your data is being stored somewhere. KRUMB.DEV flips that: Everything runs in your browser — JSON, JWT, source code, passwords never touch a network request Zero accounts — open the page, use the tool, leave. No signup wall between you and the output Clean interface — ⌘K opens a command palette to jump to any tool in seconds Open source — MIT license, deploy your own if you want The Tech Next.js, TypeScript, and Tailwind. Static-first, client-side execution for all core tools. Server routes exist only for DNS/SSL l

2026-07-27 原文 →
AI 资讯

GitOps for AI Agents: Treating Tool Configs and Memory Like Production Infrastructure

GitOps for AI Agents: Treating Tool Configs and Memory Like Production Infrastructure Stop managing AI agent configurations as fragile scripts. Adopt GitOps principles for AI, treating your tool configs and memory as version-controlled, auditable infrastructure-as-code. Learn to implement mcp.jsonc, PR-reviewed workflows, and CI validation for reliable, reproducible AI. The Configuration Chaos in Modern AI Agents Today's AI agents are powerful orchestrators, not just chatbots. They connect to dozens of external tools, databases, and APIs via configurations that define their capabilities, permissions, and memory pathways. But this configuration—often scattered across JSON files, environment variables, or proprietary dashboards—becomes a critical vulnerability. A single typo in a tool's endpoint URL or an incorrect memory namespace can cause silent failures, security leaks, or non-reproducible agent behavior across development and production. Consider a common scenario: Your team updates an AI agent's access to a vector database for its long-term memory. The change is made directly in a production dashboard by an engineer. A week later, the agent starts hallucinating corrupted context. Reverting is guesswork because there's no change log, no PR review, and no record of the previous state. This is the classic "configuration drift" problem that plagued traditional infrastructure, and it's now crippling advanced AI systems. The Infrastructure-as-Code Paradigm for AI The solution lies in applying mature DevOps practices to AI management. We must stop treating AI configurations as special snowflakes and start treating them as infrastructure as code . This means storing all defining components—tool endpoints, authentication scopes, memory indexes, and even behavioral guardrails—in a version-controlled repository. The industry-standard format for this is emerging as mcp.jsonc , a JSONC (JSON with Comments) file that defines an agent's Model Context Protocol tools and memory

2026-07-27 原文 →
AI 资讯

Talk to Your DNA: Building a Genomic RAG Pipeline with LlamaIndex and ClinVar

Have you ever looked at your raw DNA data from services like 23andMe or Ancestry.com and thought, "What on earth am I looking at?" Behind those megabytes of .txt or .vcf files lies the blueprint of you , but without a PhD in genetics, it's just a wall of "A, C, T, G." In this tutorial, we are going to bridge the gap between raw genomic noise and actionable insights. We’ll build an advanced Genomic RAG (Retrieval-Augmented Generation) pipeline. By the end, you'll have a system that takes raw SNP (Single Nucleotide Polymorphism) data, retrieves clinical significance from the ClinVar database, and generates an interactive risk guide using LlamaIndex and FAISS . If you are interested in Genomic Data Engineering , Bioinformatics with Python , or RAG (Retrieval-Augmented Generation) , this guide is for you. The Challenge: The "Needle in a Haystack" Problem A typical human genome has millions of variants. Most are harmless "junk" DNA, but some are "Pathogenic." Searching for these manually is impossible. We need a system that: Parses massive genomic files efficiently. Indexes trusted medical databases (ClinVar). Matches your specific variants against that knowledge base to provide context. The Architecture 🏗️ Here is how our data pipeline flows from raw pixels (well, raw base pairs) to structured insights: graph TD A[Raw SNP Data / VCF File] --> B(Pandas & Biopython Parser) B --> C{Filter High-Impact Variants} D[ClinVar Clinical Database] --> E(LlamaIndex Indexing) E --> F[FAISS Vector Store] C --> G[RAG Query Engine] F --> G G --> H[LLM: GPT-4o Synthesis] H --> I[Interactive Risk Report] Prerequisites 🛠️ To follow this advanced guide, you'll need: Tech Stack : Python 3.9+, Pandas, LlamaIndex, FAISS, and Biopython. Data : A sample VCF file (you can download public datasets from the 1000 Genomes Project) or your own exported 23andMe data. Step 1: Parsing the Genetic "Nonsense" First, we need to handle the raw data. 23andMe usually provides a tab-separated file. We use Panda

2026-07-27 原文 →
AI 资讯

Your agent's instructions are promises nobody checks. I counted.

I didn't set out to build a developer tool. For a long time now I've been working with AI on everything in my life — daily conversations about my daughters, planning projects, ideas for ones that don't exist yet. The goal was always the same: ease my life, get more done, and break the barrier between human and AI — stop treating it as a search box, start treating it as a partner. Somewhere along the way, the partnership got serious. The workspace where my projects live grew an instruction system for AI coding agents — the files everyone is writing now: AGENTS.md , CLAUDE.md , a skills directory, rules for how agents should plan, log, and verify their work. Then I asked an uncomfortable question: is any of it actually followed? Not "do the agents seem to follow it." Could anyone tell , from the repository alone, whether an instruction was followed? For most of my rules, the answer was no. My own audit found that the two checks my instructions said must run before every commit were invoked by nothing — no CI, no hook, no scheduled task. The rule had been enforced, for its entire life, by whoever remembered. Replaying my last 200 commits, the index-freshness rule alone would have failed on 29 of 61 eligible commits — roughly half. My instructions were not rules. They were hopes with formatting. So I wondered whether everyone else's are too. I wrote a tool and measured. What I measured, and the two honest limits that come before the numbers I analysed eight public agent-instruction collections — 1,332 instruction units, 17,611 individual instructions — each at a pinned commit SHA, with the raw per-repo JSON published alongside the tool. An instruction counts as CHECKABLE if a reviewer could tell from the repo whether it happened: it's a tick-box, or contains a runnable command, or names a concrete file artifact, or refers to an exit code, a diff, an assertion. Everything else is CLAIMABLE — the only evidence it happened is the agent saying so. Two limits, before any num

2026-07-27 原文 →
← 上一页 下一页 →