标签：#ai

I built an AI memory system inspired by one thing brains seem to do well: reinforce associations through use. Most AI memory is a notes file with search. It stores documents and retrieves them based on text similarity. I wanted something that behaved more like actual memory. I wanted paths that strengthen when you use them and fade when you do not. So mycelium stores memories as nodes with connections. This is not just a graph database. It is an active system. When you recall a few things together enough times, the link between them gets stronger. This is a Hebbian approach to storage. If two concepts appear in the same context repeatedly, the system assumes they belong together. Ignore a memory long enough and it decays. This decay is deliberate. Forgetting is a feature, not a bug. It keeps the system from becoming a static archive of everything you have ever typed. The core mechanism relies on SQLite with FTS5 for keyword matching. The connection graph lives on top of that. You might hear people talk about vectors for everything. Vectors exist as a secondary signal in mycelium. They are not the primary recall mechanism. The primary driver is this connection graph and the frequency of access. Recall is pattern completion. A query does not just match text against a document body. It fires the matching memories and spreads activation through their connections. A partial cue pulls back the whole cluster that tends to light up with it. The memories that win are the ones that are strongly connected and frequently accessed. I call those the hubs. Loading context at the start of a session deliberately returns the hubs. On average, the hubs are the load bearing knowledge. They are the concepts you have referenced most often. If you are building an agent that needs to know who you are, what you have been working on for weeks, or what your general preferences are, the hubs are the right answer. This is a feature. It is also the bug. I hit the issue during normal development

Like traditional weather models, it benefits from an expanded set of inputs.

There is a $1 million bounty for the first person providing a solution to the Navier-Stokes existence and smoothness problem.

Anthropic says power users are key to its business - it's prioritized them even when it means cutting off other popular applications, like OpenClaw. But some of these same customers say Anthropic misled them into believing they'd get more out of a top-tier pricing subscription than they did. In an expanded class action lawsuit filed […]

There's never really been a game like Grand Theft Auto VI before, one that has completely altered the lineup of games around it. Everyone, it seems, is scared of going up against Grand Theft Auto VI. Everyone, that is, except for Nintendo. The company held a 30-minute showcase this morning focused entirely on its Legend […]

This essay was written with Barath Raghavan, and originally appeared in Lawfare . In April, an artificial intelligence (AI) agent conducting a routine task at a company hit a snag, tried to solve it, and soon ended up deleting the company’s database along with all of its backups. In July, OpenAI asked an unreleased AI model to attempt a hacking test. Instead of staying in the isolated box the developers had put it in, the model hacked onto the open internet and into another company to steal the answers. And as reported in August, an AI agent booked someone into a full gym class by ...

See how an MIT researcher uses GPT-5.6 Sol with Codex to autonomously run quantum computing experiments, analyze results, and calibrate qubits.

A landmark announcement by the frontier AI lab has been overshadowed by accusations of impropriety.

Google Cloud expands its enterprise AI push with Accenture, betting on forward-deployed engineers to drive adoption and overcome deployment bottlenecks.

The White House has taken down its racist Tetris ripoff days after launching a website dedicated to "arcade games," as spotted earlier by Kotaku. The Tetris clone, called "Build the Wall," involved stacking different-sized blocks to prevent a "zombie border siege." It's not clear why the White House removed the title, though the Tetris Company […]

Nearly any TV is suitable for 4K content, but spending more gets you a better viewing experience and several other advantages.

I Used Every AI Coding Assistant I Could Find for a Month. Here's What I Actually Pay For Now Note: this is the fourth post in an ongoing series where our small editorial team tests AI tools in real workflows and writes down what we find. No affiliate links. No "sponsored by" disclaimers to hide. We pay for the tools we review, including this month's experiment, which cost us about $190 in subscriptions and a fair amount of patience. The setup I spent most of August and September doing the same two jobs across eight AI coding tools: building a small internal dashboard (React + a Node API) and maintaining an older Python service at work. Same tasks, same files, same me. The tools were GitHub Copilot, Cursor, Codeium, Tabnine, Replit AI, v0, Bolt, and Lovable. Why those eight? Because those are the ones people actually argue about in our developer group chats — and the ones a colleague keeps asking me to "just try already." I also wanted to answer one question that none of the marketing pages answer: what happens after the first week, when the novelty wears off and the tool has to earn its place in a daily workflow? Quick background so you know where I'm coming from: I'm a working developer, not a journalist. Ten years mostly backend, some frontend when I have to. I'm skeptical of anything that promises to write my code for me, and I've been burned before by autocomplete that produces confident nonsense. The short version If you only take one thing from this: Copilot is still the safest default, Cursor is the most capable if you'll actually use its chat properly, and the no-code app builders (Bolt, Lovable, v0) are not for me — but they're genuinely impressive for people who don't live in an IDE. Everything below is the longer version with the boring details, including the stuff that surprised me. GitHub Copilot: the boring, reliable choice I started with Copilot because it's what most of my team already had. The completions are fast and mostly invisible — which is th

The code is being produced faster than I can confidently review, validate, and ship it. Old workflow vs. new workflow The biggest change in my workflow is not simply that AI writes code faster. It is that my role is gradually moving away from manually implementing every detail and toward designing, orchestrating, reviewing, and validating the overall result . That sounds like a small shift, but it changes where I spend most of my engineering effort. Coding is no longer the slowest part Working with coding agents has changed how I think about development productivity. I can define a task, let an agent explore the codebase, implement the change, add tests, and return a working diff much faster than I could build everything manually. But implementation is only one stage of software delivery. flowchart LR A[Requirement] --> B[Design] --> C[Implementation] --> D[Review] --> E[Test] --> F[Deploy] AI can compress the implementation stage dramatically, but review, testing, integration, security, and deployment still have their own limits. When those stages cannot keep up, faster coding does not remove the bottleneck. It simply moves it downstream. This is also the point Red Hat recently raised in Why faster coding isn't making delivery any faster : generating code and delivering reliable software are not the same thing. I have started to notice this more clearly in my own workflow. An agent can produce a fairly large change while I am still building the mental model needed to judge whether that change is actually good. More code is not the same as more productivity Suppose I used to complete two meaningful changes in a day and AI now helps me produce six. Calling that a 3x productivity increase sounds reasonable at first, but only if the rest of the engineering system can absorb those six changes. They still need to be understood, reviewed, tested, integrated, and eventually operated in production. If review capacity or CI becomes the constraint, I have not created three ti

One thing I’ve been thinking about something that sounds simple but is actually a little tricky: what do we do after AI fixes a failed test and it passes again? There are already some interesting approaches to this. mabl looks at adaptive healing, Testim focuses on smarter locators and maintenance, and Applitools approaches changes from the visual validation side. I don’t think there’s one perfect way to handle test maintenance, it really depends on why the test failed in the first place. While exploring X360 AI Tech, this made me look at the problem a little differently. Getting a test back to green is useful, but I’m more interested in what happened along the way. Looking at the failure details, previous execution, and the actual flow can help answer a basic question: did we really fix the test, or did we just find another way to make it pass? So, after an AI fix, I’d still want to check a few things: Is the test checking the same thing as before? Does it still match the original requirement? Was the failure actually caused by a UI change? And does the fix continue to work in the next few runs? I’m starting to feel that the real value of AI self-healing isn’t just fixing tests faster. It’s helping QA spend less time fixing tests blindly and more time deciding whether the fix actually makes sense. What’s the first thing you would check after an AI-healed test turns green?

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

Original Article published on ZeroLabs . Designing Production-Grade OpenClaw Skills: Schemas, Tool Calling, and Dynamic Dispatch Key Takeaway: A deep engineering walkthrough on creating modular, reusable skills for OpenClaw agents with strict JSON schemas, fallback execution paths, and error telemetry. Structured verification, strict boundaries, and deterministic tooling prevent production failure. Implemented directly across the ZeroLabs and OpenClaw platform architecture. Image credit: labs.zeroshot.studio Why this matters: Engineering reliable systems requires moving past unstructured prompts into hardened execution contracts. Contents What is an OpenClaw skill? How do you structure the SKILL.md specification? How do you implement reliable Python tool scripts? What is dynamic dispatch and context management? FAQ What is an OpenClaw skill? In OpenClaw, a skill is a self-contained directory containing instructions, configuration schemas, and executable scripts. Instead of writing monolithic prompts that describe every possible task, skills allow agents to discover, load, and execute specialized capabilities on demand. flowchart TD A[User Request] --> B[OpenClaw Router Agent] B -->|Matches Capability| C[Load skill: domain-seo-audit] C --> D[Read SKILL.md Frontmatter & Rules] D --> E[Execute Scoped Python Script / Tool] E --> F[Return Formatted Output to Context] How do you structure the SKILL.md specification? Every skill must reside in its own subdirectory under skills/<skill-name>/ with a root SKILL.md file: --- name : domain-seo-audit description : " Scans a target URL for Core Web Vitals, OpenGraph tags, and indexability issues." version : 1.0.0 parameters : type : object properties : url : type : string format : uri description : " The full target URL to audit (including https://)." check_mobile : type : boolean default : true description : " Whether to emulate mobile viewport checks." required : - url --- # Domain SEO Audit Skill ## Overview Use this skill whe

Original Article published on ZeroLabs . Taming Vibe-Coded Technical Debt: Automated Test Harnesses for AI-Generated Repos Key Takeaway: A pragmatic strategy for refactoring AI-generated codebases, eliminating dead boilerplate, and establishing regression test harnesses before shipping to production. Structured verification, strict boundaries, and deterministic tooling prevent production failure. Implemented directly across the ZeroLabs and OpenClaw platform architecture. Image credit: labs.zeroshot.studio Why this matters: Engineering reliable systems requires moving past unstructured prompts into hardened execution contracts. Contents What causes vibe-coded technical debt? How do you build a safety test harness? What is the 4-step refactoring loop for AI code? How do you clean dead dependencies and boilerplate? FAQ What causes vibe-coded technical debt? AI coding models are optimized to satisfy the user's immediate prompt. When asked to add a feature, models often take the path of least resistance: Copy-Pasting Logic : Duplicating utility functions across multiple files rather than importing shared modules. Swallowing Errors : Wrapping fragile database or network calls in broad try/except: pass blocks. Dependency Sprawl : Installing heavy npm packages or Python libraries for trivial single-line operations. flowchart TD A[Vibe Coded Prototype] --> B[Generate Smoke & Contract Tests] B --> C[Run Static Analysis & Linters] C --> D[Identify Duplication & Dead Imports] D --> E[Scoped AI Refactor on Single Module] E --> F[Run Test Suite] F -->|Pass| G[Commit Refactor] F -->|Fail| E How do you build a safety test harness? Before asking an AI agent to clean up or refactor an existing repository, you must write automated smoke tests that verify critical user journeys. If you don't have tests, ask the agent to write tests before modifying any implementation code: # tests/test_smoke_endpoints.py import pytest import httpx BASE_URL = ' http://localhost:3000 ' def test_homepage

Original Article published on ZeroLabs . Context Engineering with Claude Code: The Spec-First Pipeline for Production Codebases Key Takeaway: How to structure markdown specification files, linting contracts, and context boundaries to eliminate hallucinated refactors when coding with Claude Code and modern CLI agents. Structured verification, strict boundaries, and deterministic tooling prevent production failure. Implemented directly across the ZeroLabs and OpenClaw platform architecture. Image credit: labs.zeroshot.studio Why this matters: Engineering reliable systems requires moving past unstructured prompts into hardened execution contracts. Contents What is the problem with unstructured conversational prompting? How does the Spec-First Pipeline work? What belongs in a production feature spec? How do you enforce automated verification loops? FAQ What is the problem with unstructured conversational prompting? When developers ask CLI coding agents to 'Fix the user profile page' or 'Refactor our database queries' , the model must guess which files to edit, what interfaces to preserve, and how to verify correctness. This ambiguity leads to three common failure modes: Collateral Damage : The agent modifies unrelated utility functions, introducing silent regressions across the codebase. Context Saturation : The agent reads dozens of unnecessary files, exhausting its context window and forgetting the primary objective. Premature Completion : The agent claims a task is complete without running linters, compilers, or test suites. flowchart TD A[Feature Request / Bug] --> B[Draft SPEC.md in Repo] B --> C[Review Interface & Target Files] C --> D[Feed Spec to Claude Code / CLI Agent] D --> E[Agent Edits Code in Target Files] E --> F[Run Deterministic Test Suite] F -->|Tests Fail| E F -->|Tests Pass| G[Commit & Open PR] How does the Spec-First Pipeline work? The Spec-First Pipeline replaces open-ended chatting with a deterministic three-stage workflow: Stage Artifact Action O

Pusheen is getting her first game, and it will appear exclusively on Apple Arcade. Launching October 1st, Pusheen's Place lets you collect and care for more than 100 Pusheens as you play minigames and decorate rooms for Pusheenicorn, Pancake Pusheen, and other variations of the cartoon cat. In the mix of minigames, you'll "sort color […]

Google is speeding up Chrome’s release schedule to ship security patches and new features faster.