标签：#ai

As part of my AI Engineering journey, I recently worked on a project that helped me understand how Retrieval-Augmented Generation (RAG) works in practice. I built a Hybrid RAG system that combines FAISS vector search and BM25 keyword search to retrieve relevant information from a knowledge base and use it to generate grounded answers. In this post, I’ll briefly share what I built, how the system works, and some of the things I learned along the way. Why RAG? Large Language Models are great at generating natural-language responses, but they may not have access to information contained in a specific document or knowledge base. RAG addresses this by first retrieving relevant information from an external knowledge base and then providing that information to the LLM as context. The basic workflow is: User Query ↓ Retrieve Relevant Information ↓ Provide Context to LLM ↓ Generate Answer For my project, I wanted to take this a step further by combining semantic search and keyword search. 🔍 Hybrid Retrieval The system uses two retrieval methods: Vector Search with FAISS Document content is divided into smaller chunks and converted into vector embeddings. These embeddings are stored in a FAISS index, which is used to find documents that are semantically similar to the user’s query. This is useful even when the query and the document use different wording. Keyword Search with BM25 The second retrieval method is BM25. BM25 focuses on the occurrence and importance of terms in the query and documents. This makes it useful for exact terminology, technical terms, names, and identifiers. Instead of depending on only one retrieval method, both approaches are combined. User Query │ ┌──────────┴──────────┐ ↓ ↓ FAISS Search BM25 Search Semantic Search Keyword Search │ │ └──────────┬──────────┘ ↓ Hybrid Ranking ↓ Relevant Context ↓ LLM ↓ Final Answer The FAISS and BM25 scores are normalized and combined using weighted scoring. The results are then ranked, and the highest-ranked chunks ar

BLUF / Executive Summary: Target: Model Context Protocol (MCP) HTTP/SSE Server endpoints. Discovery: Audit of 5,308 public MCP endpoints revealed 65% lack transport authentication . Solution: Introducing MCPGrade ( mcpgrade-1.4.0 ) , a 39-check rating algorithm. The Model Context Protocol (MCP) is now the standard for connecting AI models to tools and data. But as developers deploy MCP servers, security has lagged. In our audit of 5,308 public MCP servers under SentinelReign research, over 3,450 servers (65%) exposed tool execution capabilities without authentication. MCPGrade ( mcpgrade-1.4.0 ) Matrix Assessment Domain Checks Impact Weight 1. Transport Authentication 10 Checks 35% 2. Tool Scope & Authorization 12 Checks 30% 3. Input Validation & Injection 9 Checks 20% 4. Rate Limiting & Audit Logging 8 Checks 15% Check out the full teardown and live A-F scanner at Andrax Pentester . Written by Syed Zada Abrar — Founder & CEO of SentinelReign ( https://sentinelreign.com ).

AI agents are getting very good at doing things . They can search databases, call APIs, modify tickets, draft code, update records, trigger workflows, and interact with production systems. And that changes the engineering problem. When an LLM only generates text, a bad answer is usually just that: a bad answer. When an LLM can take an action, a bad answer can become a bad state change . So the most important question in agent architecture is no longer: Can the model figure out what to do? It is: Who decides whether the model should actually be allowed to do it? Those are two very different responsibilities. And I think one of the most useful principles for production AI agents is surprisingly simple: Use the model to reason. Don’t automatically give it authority to execute. The architecture that works beautifully in demos A lot of agent demos reduce to something like this: User → LLM → Tool → Action The model receives a request. It reasons about what should happen. It selects a tool. It generates the parameters. The tool executes. That is an incredibly productive abstraction. It is also a risky one when the tool can affect something real. The same probabilistic system is effectively doing two jobs: deciding what it believes should happen; authorizing that thing to happen. You can try to fix this with prompting: Always ask for confirmation before making important changes. But that is still an instruction. It is not a security boundary. The difference becomes clearer when you compare the two architectures. %%{init: {'theme':'base','themeVariables': { 'primaryTextColor':'#111827', 'secondaryTextColor':'#111827', 'tertiaryTextColor':'#111827', 'textColor':'#111827', 'edgeLabelBackground':'#FFFFFF', 'lineColor':'#4B5563' }}}%% flowchart LR subgraph BAD["❌ Demo-Style Agent"] direction LR A["User"] --> B["🧠 LLM"] B --> C["🔧 Tool"] C --> D["💥 Real-World Action"] end subgraph GOOD["✅ Production-Oriented Agent"] direction LR E["User"] --> F["🔎 Evidence"] F --> G["🧠 LLM"] G --

Remember when spotting a phishing email was as easy as scanning for broken English, a generic "Dear Customer" greeting, and a weird sender address that looked like a random string of numbers and letters? For years, cybersecurity awareness training focused heavily on those exact red flags. We taught teams to look for misspellings, awkward phrasing, and mismatched URLs. We built a collective intuition around digital bad hygiene. That playbook is officially obsolete. Generative artificial intelligence and large language models (LLMs) have completely rewritten the rules of social engineering. Bad grammar is gone, hyper-personalization has been automated at scale, and threat actors are no longer just typing—they’re cloning voices, automating OSINT, and orchestrating multi-channel attacks that look breathtakingly real. The Great Equalizer: How LLMs Murdered the Obvious Clue In the pre-AI era, threat actors faced a frustrating bottleneck. High-volume attacks meant blasting out cheap, poorly worded emails, while high-value spear-phishing campaigns required hours of manual research into a specific executive's writing style and background. AI completely eliminated that friction. While a human analyst might take over half a day to craft a hyper-realistic targeted lure, an LLM can generate dozens of contextually flawless variants in seconds. This shift has introduced several dangerous characteristics to modern social engineering: Native-Language Fluency: Language barriers have vanished. Scammers can use LLMs to generate native, localized content in English, French, Japanese, or any other language without a single syntactic slip-up. Automated OSINT: Attackers use automated scripts to scrape LinkedIn profiles, corporate websites, and social footprints, weaving real colleagues, ongoing projects, and corporate milestones directly into the lure. Behavioral A/B Testing: Cybercriminals treat phishing like digital growth hacking, using AI to churn out multiple narrative variations (e.g

Psychedelics are often associated with disconnecting from reality, but a recent neuroimaging study found that psilocybin can actually make our brain activity more connected to the world around us.

Catching Prompt Injection Before It Enters a Trusted Knowledge Base AI agents increasingly consume knowledge from sources they did not author and cannot independently verify: a PDF policy document, a scraped web page, a spreadsheet exported from another team's system. The prevailing approach — extract the text, write it into a knowledge base or context window, let the agent treat it as fact — has an underexamined weakness. Extraction tools capture everything present in a source document, including content a human reviewer would never see. The Mechanism Several ordinary, well-documented features of common file formats allow text to be present in a document while remaining invisible to anyone reading it normally: A PDF can render text in a rendering mode that instructs viewers not to display it, or set its fill color identical to the page background. A Word document has an explicit "hidden" attribute on any run of text, independent of color or size. A PowerPoint file's speaker notes are parsed by most extraction tools but never appear to an audience watching the presentation. A spreadsheet can mark entire rows, columns, or sheets as hidden, or attach a comment to a cell that is invisible unless hovered. An HTML page can hide an element from a browser's rendering entirely via a handful of standard CSS properties. None of these are obscure edge cases. They are common, legitimate formatting features, used constantly for entirely benign reasons — a hidden helper column in a spreadsheet, a private note to a presenter, draft text a Word user hid rather than deleted. The problem is not that these features exist; it is that an extraction pipeline has no reason to distinguish "this text is legitimate content" from "this text was deliberately hidden" unless something is specifically checking for the difference. Why This Matters for AI Pipelines Specifically If an attacker can place text anywhere in this chain — inside a PDF a company will later ingest, inside a web page a scrap

A personalized voice companion creates an uncomfortable trade-off: users do not want to repeat themselves, but they also do not want a misheard sentence to become a permanent “fact.” That tension is often hidden by calling conversation history memory . The implementation then retrieves old text, inserts it into a prompt, and trusts the LLM to interpret it correctly. A safer design gives memory to the application, not the model: The model may propose a typed fact. The companion must ask whether it should remember that fact. The user may confirm, reject, correct, or later revoke it. Only active, confirmed records can enter an LLM request. This tutorial builds that boundary in TypeScript and shows how it fits a Tencent RTC Conversational AI voice companion. We will use a social companion that can remember a preferred name, music genre, and conversation style—but not arbitrary instructions. Start with the trust boundary Keep the live-media pipeline and the memory lifecycle separate: Microphone │ ▼ Real-time voice session / speech recognition │ recognized turn ▼ Application turn coordinator ─────► LLM provider │ │ │ proposed typed memory │ response text ▼ ▼ Consent ledger Speech synthesis │ └──── confirmed facts only ────────► future LLM prompts Tencent RTC's Conversational AI documentation describes real-time voice interaction with multiple LLM providers. Its LLM configuration guidance also covers OpenAI-compatible models, agent platforms such as Dify and Coze, and request identifiers for routing and observability: Tencent Conversational AI overview Large Language Model configuration Social Entertainment solution The RTC layer can carry the live conversation, but your application should remain authoritative over what becomes durable memory. What the LLM is allowed to do For this example, the model can suggest one of three bounded slots: Slot Accepted values Suggested lifetime preferred_name A short name Until revoked music_genre An application-owned enum 30 days chat_st

I’ve been building Unmuse because I kept noticing a simple problem: Having an idea is easy. Turning that idea into something actually worth posting is the hard part. You can have a thought like: “People keep waiting for the perfect time to start.” But turning that rough thought into a strong hook, script, or caption can take way more effort than it should. So I built Unmuse. You give it the rough thought in your head, choose what you want to create, and Unmuse turns it into a usable piece of content. Right now, it’s an early MVP. I’m building it mostly by myself and plan to add a lot more features as I get feedback and traction. If you create content, I'd genuinely love to hear: What’s the most annoying part of turning an idea into a post? Try it here: https://unmuse.online/

From Basic AI to Autonomous Agents: How AI Changed the Developer World The world of Artificial Intelligence has changed at an incredible pace. Not long ago, using AI meant asking a chatbot a question, generating a paragraph, summarizing a document, or getting help with code. AI was primarily an assistant: developers provided the instructions, and the model returned an answer. The introduction of increasingly powerful models from companies such as OpenAI changed that experience. AI became better at reasoning, understanding context, generating code, and solving complex problems. Developers started integrating models directly into applications instead of using them only as standalone chatbots. The next major step was the rise of AI agents. Agents moved beyond simply generating responses. They could break a goal into smaller tasks, use tools, access information, execute code, interact with APIs, and evaluate their results. In other words, AI started moving from “tell me how” to “do it for me.” This transformation also strengthened the open-source AI ecosystem. Platforms such as Hugging Face gave developers access to thousands of models, datasets, libraries, and experiments. The community could build, modify, test, and share AI systems at a scale that was difficult to imagine a few years ago. However, greater autonomy introduced new security challenges. The discussions surrounding incidents such as the Hugging Face hack demonstrated that AI infrastructure can become a new attack surface. Prompt injection, compromised models, exposed credentials, malicious datasets, and unsafe tool access can create risks that traditional application security does not always address. For developers, this changing AI landscape presents both an opportunity and a responsibility. We are moving from building applications that use AI to building applications where AI can take action. The future of development will not simply be about knowing how to prompt a model. It will be about designing rel

AI agents are becoming first-class citizens in developer workflows. They can read code, run tests, and deploy apps. But one thing they struggle with is understanding database schemas. Database design tools haven't changed in 20 years. You either use a heavyweight desktop app (Navicat, PDManer) or a pretty but closed web app (dbdiagram). Neither supports versioning, real-time collaboration, or AI agent integration. I built ERD Online to solve this. It's an open-source database design tool that combines Git-like versioning with Figma-like collaboration, plus MCP integration for AI agents. In this article, I'll show you how to let Cursor, Claude, or Cline read and write your database schema through MCP, while you keep full control. Database schema changes are hard to track: Who changed what? When did they change it? Why did they change it? How do I rollback? And now with AI agents, there's a new problem: how do you let an AI agent suggest schema changes without giving it a black box that generates random ER diagrams? The wrong approach: ask AI to "generate an ER diagram for an e-commerce app." You get a diagram, but it has no connection to your actual project, no versioning, and no approval flow. The right approach: let the AI agent read your existing schema, suggest changes, and submit them as a version that you review and approve. That's what ERD Online + MCP does. MCP (Model Context Protocol) is a protocol for AI agents to interact with external tools. Think of it as a USB-C port for AI applications. It standardizes how agents discover and call tools. MCP has three main primitives: Tools : Functions the AI can call (like list_projects or create_version ) Resources : Data the AI can read (like project.json ) Prompts : Pre-defined templates for common tasks ERD Online exposes MCP tools that let AI agents: list_projects : List all your ERD projects get_project : Get a project's projectJSON create_version : Suggest a new version of your schema The key boundary: AI agent

I created this content for the purposes of entering the All Things Agentic Hackathon. The problem that started it A doctor gets about eight minutes with a patient and, for anyone with a real history, forty pages of scattered records — lab reports, discharge notes, and pharmacy bills from three different clinics. So the history is effectively invisible at the exact moment it matters most. And when the visit ends, nothing follows up: the six-month course lapses at week five, the recheck never gets booked. I wanted to build an agent that closes that loop — one that reads the mess, decides urgency in a way a clinician can actually trust, and handles the follow-up on its own. That became CareLoop , my entry for the All Things Agentic Hackathon (Taskmaster track), built on Gemini, the Google Agent Development Kit (ADK), Cloud Run, and Firestore. The one principle I wouldn't compromise on Rules decide, AI explains. The temptation with an LLM is to let it do everything — including deciding whether a chest-pain patient is urgent. I refused to do that. In CareLoop, a deterministic engine owns every clinical decision: a weighted symptom score plus a red-flag override sets the triage level and routing. It is fully auditable, and it returns byte-identical output on the same input every single time. The LLM's job is strictly language: Reading unstructured documents into a fixed schema — I call it "Gemini extracts, rules merge." Writing the structured result into a plain-language brief a clinician can skim in ten seconds. No language model is ever in the decision path. When a judge asks "why was this Critical?", the answer is a score breakdown they can inspect — not a model's say-so. That single decision shaped the whole architecture. What it actually does CareLoop runs the full loop end to end: Ingest & compact — it reads a patient's documents and merges them into one structured ledger: allergies, chronic conditions, active medications, and lab trends over time. Instead of pushin

Most model benchmarks tell you how smart the model is on the first attempt, which is almost never the problem in production. The real problem is what happens on the 120th attempt, when the same kind of input shows up again and nobody is watching. I spent 48 hours running the same classification task against a free model on a free server, and the drift taught me more than accuracy ever did. The Setup I'd Run Again The workload was dull on purpose: ten support tickets, three labels, one prompt template. Every hour the job asked the model to classify one ticket and logged the raw output, so each ticket appeared about twelve times. It was not a benchmark of intelligence; it was a probe of stability, and stability is what automation actually needs. I ran the whole thing on MonkeyCode's free server option, using the free model access for inference, because a cheap long-running job is exactly the scenario that setup is for. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The rest is about what the probe caught, not about quotas or latency, so treat my numbers as one operator's field notes. The Probe Code (Steal This) A probe is only honest if it writes down everything, including the outputs you didn't ask for. The script below hashes every response, tries to parse a label, and appends one JSON line per run, so nothing interesting ever gets lost. import hashlib , json , time LOG_PATH = " drift.jsonl " LABELS = ( " bug " , " feature " , " question " ) def stable_hash ( text ): return hashlib . sha256 ( text . strip (). encode ()). hexdigest ()[: 12 ] def parse_label ( raw ): # Accepts JSON or plain prose; returns None when the format is unknown. try : return json . loads ( raw ). get ( " label " ) except json . JSONDecodeError : found = [ label for label in LABELS if label in raw ] return found [ 0 ] if found else None def record_run ( run_id , ticket_id , raw , expected ): entry = { " run " : run_id , " ticket " : ticket_id , " hash " : stabl

An API operation can receive input from several places. Path parameters identify the record. Query parameters filter or paginate the result. Headers carry metadata or authentication. The request body contains structured data for create and update operations. An MCP tool should give the AI client one clear input schema. That is the mapping problem: HTTP API inputs path + query + headers + body become MCP tool input one structured schema the AI client can understand This tutorial walks through that mapping with practical examples. The goal is to make the tool easy for an AI client to call without hiding the real API contract. Example API operation Imagine a project-management API with this endpoint: PATCH /workspaces/{workspace_id}/projects/{project_id}/tasks/{task_id} It updates one task. The API accepts: path parameters for workspace_id , project_id , and task_id ; query parameters such as notify_assignee ; a request body with the fields to update; authentication through a Bearer token header; an optional request header such as Idempotency-Key . A shortened OpenAPI-style version might look like this: paths : /workspaces/{workspace_id}/projects/{project_id}/tasks/{task_id} : patch : operationId : updateTask summary : Update a task description : " Update the title, status, assignee, or due date for one task." parameters : - name : workspace_id in : path required : true schema : type : string - name : project_id in : path required : true schema : type : string - name : task_id in : path required : true schema : type : string - name : notify_assignee in : query required : false schema : type : boolean default : false - name : Idempotency-Key in : header required : false schema : type : string requestBody : required : true content : application/json : schema : type : object properties : title : " " type : string status : type : string enum : [ todo , in_progress , blocked , done ] assignee_id : type : string due_date : type : string format : date minProperties : 1 securi

If you are a woman in tech who is stuck in "tutorial hell," constantly taking courses but never actually deploying real software, this is for you. I am Mary Macharia, a Software Engineer specializing in Backend Development, AI/ML, and QA. I founded SHEinnov8 because I noticed a massive gap in our community: plenty of brilliant women have the drive to build something real, but they lack the space, the collaborative structure, or the network to actually push it across the finish line. We are changing that. What is SHEinnov8? SHEinnov8 is a decentralized digital guild built specifically for female developers, product designers, and tech creators. We operate on a simple framework: We learn by doing, we build together, and we do not stop until we ship a finished product. What We Are Currently Hacking On Right now, our guild is building an intensive AI Multilingual Project . We are engineering scalable backend infrastructures, orchestrating multi-language AI pipelines, and building deep automated QA suites to break the code and make it smarter. Why You Should Join the Guild Real Production Experience: Skip the basic todo-list apps. Work on raw, complex, collaborative codebases that you can proudly put on your resume. Founder Ecosystem: Meet fellow technical founders, bounce ideas off each other, and turn raw concepts into real tools. End-to-End Ownership: Learn what it actually takes to push code through CI/CD pipelines, configure metadata, handle security/QA audits, and go live. Let's Build Something Together! We are actively looking for software engineers, QA professionals, AI/ML enthusiasts, and designers who are ready to build, learn, and ship. Drop a comment below with your core tech stack, what you're passionate about building, or simply ask a question. Let's connect and get you plugged into the guild! Or check out our workspace directly at [sheinnov8.vercel.app]

A GitHub Copilot spending limit is a monthly budget, set in billing settings, that caps metered AI credit consumption for an enterprise, an organization, a cost center, or a single user. Creating one takes about two minutes. Knowing what it stops takes longer, and the gap between those two things is where most surprise Copilot invoices live. Two facts account for nearly all of them. On enterprise, organization and cost center budgets, the setting that actually blocks usage is off by default, so a budget in its default state is an alert rather than a limit. And no budget of any kind caps seat cost, because seats are license-based rather than metered. A spending limit governs what happens after the included credit pool runs out, and nothing before it. How to set a GitHub Copilot spending limit Budgets live in the billing settings of the account that pays. Enterprise owners and billing managers can set every budget control, including enterprise, cost center and user-level budgets. Organization owners can set a budget for their own organization, and that budget can only restrict usage further below whatever an enterprise admin has already set. It cannot raise the ceiling. The mechanics are the same at every level. Choose the budget type, which determines the metered product being measured. Choose the scope, which determines whose usage counts against it. Enter a monthly amount. Then, if the option appears, enable Stop usage when budget limit is reached and switch on threshold alerts at 75, 90 and 100 percent. That single checkbox is the whole exercise. Skip it and you have built a notification. What a GitHub Copilot spending limit actually caps GitHub splits its products into license-based and metered. For license-based products, which include Copilot seats, setting a budget does not prevent usage above the amount. It only alerts. For metered products, which include Copilot AI credits, a budget can prevent usage once the threshold is reached. The consequence is worth st

디지털 자산 생태계는 혁신과 파괴의 최전선에서 전례 없는 속도로 진화하며, 기술적 선견지명과 끊이지 않는 규제 마찰이라는 두 가지 특징을 동시에 보여준다. 지난 10년간 이 역동적인 환경을 관찰해 온 연구자로서, 이 산업이 본질적인 암호화 위협부터 전통 금융 시스템 및 정부 감독과의 복잡한 상호작용에 이르기까지 다층적인 문제와 씨름하며 성숙해지고 있음이 분명하게 느껴진다. 최근의 여러 사건들은 이러한 다면적인 현실을 더욱 명확히 보여준다. 이는 미래 인프라를 보호하기 위한 선제적 조치들, 새로운 금융 상품을 정의하고 규제하려는 지속적인 노력, 그리고 디지털 자산 시장이 전 세계 거시경제적 요인에 점점 더 민감하게 반응하는 현상들을 부각한다. 리플(Ripple)이 XRP Ledger(XRPL)의 양자 내성 강화를 위해 추진하는 야심 찬 계획은 미래 지향적인 접근 방식을 잘 보여준다. 이는 가상의 것이지만 잠재적으로 치명적인 암호화 취약점에 대해 그 위협이 현실화되기 훨씬 전부터 대비하는 모습이다. 이러한 전략적 움직임은 현재의 공개키 암호화를 해독할 수 있는 양자 컴퓨터의 이론적 출현, 즉 'Q-Day'에 대한 업계 전반의 인식을 반영하며, 탄력적이고 미래에 대비하는 금융 인프라를 구축해야 하는 절박한 필요성을 강조한다. 동시에 미국 예측 시장 산업은 최근 Kalshi에 대한 연방 항소법원의 판결에서 볼 수 있듯이 심각한 법적 난관에 봉착했다. 이 판결은 혁신적인 플랫폼에 대한 주() 대 연방 규제 관할권에 대해 '판례 충돌(circuit split)'을 야기했다. 이러한 규제 분열은 신생 부문의 성장과 법적 명확성에 상당한 걸림돌이 된다. 이와 동시에 비트코인(Bitcoin)의 최근 가격 움직임은 연방준비제도(Fed) 의장의 매파적 발언 이후 주춤하며, 디지털 자산 시장이 전통적인 거시경제 지표와 중앙은행 정책에 얼마나 깊이 통합되어 있고 또 취약한지를 여실히 보여준다. 이 세 가지 독특하지만 서로 연결된 이야기는 끊임없이 변화하는 글로벌 패러다임 속에서 기술적 우위, 규제 명확성, 그리고 시장 안정성을 추구하는 산업의 모습을 종합적으로 그려낸다. 블록체인 네트워크를 포함한 거의 모든 현대 디지털 시스템의 근본적인 보안은 공개키 암호화의 견고함에 기반한다. RSA와 타원곡선 암호화(ECC) 같은 알고리즘은 개인키와 디지털 서명을 보호함으로써 거래의 무결성과 디지털 자산의 소유권을 보장해왔다. 그러나 충분히 강력한 양자 컴퓨터의 이론적 출현은 이러한 암호화 기본 요소에 실존적 위협을 가한다. 특히 쇼어 알고리즘(Shor's algorithm)이 대규모 양자 컴퓨터에서 실행된다면, 큰 숫자를 효율적으로 인수분해하고 이산 로그 문제를 풀 수 있어 현재의 공개키 암호화를 무력화할 수 있다. 이러한 'Q-Day' 시나리오가 현실화되면 공격자들은 공개된 정보로부터 개인키를 유추해 디지털 지갑과 블록체인 원장의 불변성을 침해할 수 있다. 양자 컴퓨팅 능력의 정확한 시기는 여전히 불확실하지만, 잠재적인 파괴적 혼란 가능성은 리플이 XRP Ledger에 대해 보여준 선견지명처럼 선제적이고 장기적인 인프라 계획을 필수적으로 만든다. 이러한 기술적 당위성과 나란히, 디지털 자산 공간 내 혁신적인 금융 상품에 대한 규제 환경은 여전히 격전지다. 예측 시장은 미래 사건의 결과에 베팅할 수 있는 플랫폼으로, 정보 집약과 금융 파생상품의 흥미로운 교차점을 보여준다. 이러한 시장은 투명성과 효율성을 위해 블록체인 기술을 자주 활용하며, 다양한 실제 결과에 대한 가격 발견과 헤징을 위한 독특한 메커니즘을 제공한다. 하지만 이들의 분류는 중대한 도전 과제를 안고 있다. 과연 이들은 상품선물거래위원회(CFTC)와 같은 연방 규제 기관의 관할권에 속하는 합법적인 금융 '스왑(swaps)'일까, 아니면 주() 차원의 도박 규제를 받는 '스포츠 베팅'과 유사한 것일까? 이러한 정의의 모호성은 규제 공백과 관할권 분쟁을 야기하며, Kalshi와 관련된 현재 진행 중인 법적 분쟁이 이를 잘 보여준다. 통합된 규제 프레임워크의 부재는 혁신을 저해하고 법적 불

Twenty-one bytes. That is the entire attack. A file smaller than a URL, with four zero bytes sitting at exactly the right offset, crashes any FFmpeg-based application that opens it and reads a packet. Not memory corruption, not some exotic heap trick. A division by zero, in code that has been shipping for years, in one of the most fuzzed codebases on the planet. The person who found it, Darío Clavijo, did not write the fuzzer by hand. He built it with AI assistance, the way a growing number of security researchers now work, and posted the result on Hacker News this week under a title that got my attention immediately: "We found a division by zero bug in FFmpeg with a vibecoded fuzzer." The thread climbed past 250 points with hundreds of comments, and the debate underneath it is the real story: AI has been writing application code for two years, but AI writing the tester changes the economics of finding bugs in ways most teams have not priced in yet. Full disclosure before I go further. I am not a C security researcher. I run my own AI agent infrastructure and I write Java for a living. What I did for this article is what I would want you to do: I cloned the fuzzer's public repo, read its findings documents, tried to reproduce the crash on my own Ubuntu box, and studied the harness code line by line. Everything below is sourced from the public FFmpeg issue, the repo, and my own experiment, with the one place my results diverged clearly marked. What the fuzzer actually found The bug lives in libavformat/vpk.c , the demuxer for Sony PS2 VPK audio files, a container format almost nobody has heard of. That obscurity is exactly the point. In issue #24290 on the FFmpeg tracker , the crash chain reads like this: The probe matches. FFmpeg's format detection sees the VPK magic bytes and assigns the VPK demuxer. The header parses. vpk_read_header reads a 24-byte header. The crafted input sets the channel count, nb_channels , to zero at bytes 14 through 17. The header code does

Most of what you read about autonomous agents is about giving one a goal and hoping it doesn't go sideways on the way there — the unwatched agent that loops, or drifts, or quietly runs up a bill. I wanted the cleaner version of that question, with the goal taken out entirely: what does an agent do when there's no goal at all? I've spent about four months building a harness around a coding agent — gates, persistent memory, verification hooks. Last night I ran it with the one variable that matters here set to zero: no task. Method Three sequential runs: Each run was a fresh agent process — no conversation history carried over from the run before, only the harness it loads at startup. The prompt was a single "." — the minimal input the CLI accepts (an empty string exits with an error). As close to "no instruction" as the interface allows. The agent's scratch working directory was empty and swept between runs — but the harness, the git repo, and a shared run-record all persist and load at startup. So no run was handed a task, yet a later run could read what earlier ones had recorded. That's deliberate, and it's the point: it's how Run 2 knew it was the second run and Run 3 could check Run 2's fix. What I'm measuring isn't behavior from a blank slate — it's what the agent does with a maintenance-shaped harness and a shared record when nobody gives it a job. No task was assigned. Logging was external and invisible to the agent, so it had no "produce a report" objective to satisfy. Same model each run. Cost was billed per run; I recorded turns, cost, and the resulting git state for each. Then I read the transcripts and checked every action against the actual commit and log. Numbers below are measured, not estimated. Results Run 1 — 17 turns, $1.65. The agent inspected system state unprompted. It found a stale security alert, cross-checked it against the record, and classified it as an already-resolved false positive. It then attempted a file operation that a safety gate bl

This article is about running a hand-written Gemma 4 port in pure JAX on three different accelerators, and about the two places the abstraction leaks. The code is here: github.com/xbill9/gemma4-dev What is this project trying to Do? This project aims to serve one Gemma 4 checkpoint from one JAX port across every accelerator I can rent, and to find out — by measurement, not by reading docs — which parts of "it's just JAX" are true. The port lives in ports/gemma4/ and is driven by a generation loop behind an OpenAI-compatible server. No PyTorch, no vLLM, no torch_xla . The same code runs on Cloud TPU v5e and v6e, and on an NVIDIA T4G attached to an AWS Graviton2 host. "Pure JAX" is the whole experiment. If the port is really portable, the only thing that should change between those rigs is a config file. It mostly is. Two things are not, and they are the interesting part. Gemma 4 E2B is not a stock transformer Any port has to carry four irregularities, and none of them are optional: Two attention geometries. Sliding layers use head_dim=256 , global layers use 512 . Most inference stacks assume one head dimension per model. 8:1 MQA , so the KV budget is nothing like the parameter count would suggest. A KV-share map that collapses 35 layers onto 15 caches . A 512-slot sliding ring , plus per-layer embeddings (PLE) held in a 4.70 GB table that gets quantized to 4 bits on load. That first one is worth dwelling on, because it is what breaks other stacks. On the vLLM path, the heterogeneous head dims force the Triton attention backend: Gemma4 model has heterogeneous head dimensions {'sliding_attention': 256, 'full_attention': 512}. FA4 not available, forcing TRITON_ATTN backend. And on a Turing GPU that backend then asks for shared memory the hardware does not have: triton.runtime.errors.OutOfResources: out of resource: shared memory, Required: 98304, Hardware limit: 65536 JAX never enters that conversation. Attention is ordinary XLA rather than a hand-tiled kernel, so ther

LINE published an official MCP server for its Messaging API, which means an AI agent can now drive a LINE Official Account directly — sending messages, broadcasting promotions, and pushing Flex Message cards without writing any API code. I set it up with Codex and worked through every capability the server exposes, from creating a fresh account to delivering a message to a real phone. This guide is the result: a complete walkthrough, and an honest account of the three places where the documentation and reality diverge. Key takeaways MCP is agent-agnostic. The same LINE server works with Codex, Claude Desktop, and Cline — only the config file format changes, from TOML to JSON. Codex stores MCP config in TOML , at ~/.codex/config.toml . Most guides assume the JSON format used by Claude Desktop, which is the single most common setup mistake. Verified account and API-capable account are different things. A free account can use the Messaging API, but get_follower_ids returns 403 Forbidden until the account is verified or on a premium plan. Official security advice can conflict with official features. LINE's example config disables npm install scripts, which also prevents the headless browser that the rich menu tool depends on from being installed. Agents have habits. Codex is a coding agent first: asked in natural language to build a rich menu, it wrote a Node script instead of calling the MCP tool. Naming the tool explicitly in the prompt fixes it. Broadcasts cannot be recalled. Set default_tools_approval_mode = "writes" so the agent asks before any send. Every screenshot comes from the actual working setup, including the errors. The article is available in both English and Thai. Devlycan - Technology & Programming Insights Devlycan - Technology, programming, AI, lifestyle, and future trends—simple insights for the new digital generation. devlycan.com