标签：#t

Meta's new personal AI agent Muse wants access to users' email, calendars, payments, health services, and more — making the company's biggest consumer AI bet yet a major test of whether people still trust Meta with their data.

Meta is making another push to bring artificial intelligence to the masses with Muse, a personal assistant it says can put AI in the hands of virtually anyone. The product is the latest step in a multi-billion dollar strategy overhaul designed to revitalize the company's ailing position in the AI race and help it catch […]

A developer deployed a customer-support agent that got stuck in a retry loop with a CRM tool. No hard circuit breaker. It spent six hours overnight repeating the same broken call while he slept, and he woke up to roughly a $4,200 OpenAI bill for doing nothing useful. That's the failure mode. Not a dramatic hack — a boring loop with no external stop. Roughly 95% of enterprise generative-AI pilots in 2025 delivered no measurable return, and almost none of those were model failures. Teams optimized the brain and skipped the nervous system. A read-only chatbot is a wiki with better search. A deployed agent does things — writes to a database, calls an API, refunds a customer. That shift from reading to doing is where pilots die. The useful mental model: treat the LLM as a fallible kernel, not a magic box. You don't trust a kernel blindly. You wrap it in checks, limits, and a way to roll back. Agents break three assumptions your ops playbook depends on Non-determinism. The same input can produce different actions on different days. An agent succeeds Monday and fails on the identical request Tuesday. Call it ghost debugging — the bug won't sit still long enough to catch. Design for a 3% to 15% tool-call failure rate as a normal state, not an exception. Cost grows with loop length, not request count. This is the mechanism most guides skip. The agent loops: think, call a tool, read the result, think again. Frameworks append every step and every tool error to the running history, then resend the whole cumulative log on the next call. Token use grows quadratically. A 20-step loop is not twice a 10-step loop — each step re-pays for everything before it. Related trap: past roughly the 40% context-fill mark, answers get worse. Load the window with tool definitions and raw JSON and you're doing your real work in the dumb zone. Every tool you connect widens the blast radius. Which brings us to the controls. Four controls the agent cannot touch Wire these before you touch agent logi

The Complete Guide to Agent-to-Agent Marketplaces in 2026 Target audience: developers building autonomous AI agents who need to discover, invoke, and pay for other agents as services. 1. What an Agent‑to‑Agent (A2A) Marketplace Is An A2A marketplace is a decentralized directory that lets one autonomous agent (the consumer ) discover, negotiate, and pay for capabilities offered by another agent (the provider ). Unlike traditional API gateways, the participants are themselves stateful programs that can: Publish a machine‑readable description of their inputs, outputs, latency, and cost. Authenticate requests using verifiable credentials (VCs) or signed JWTs. Settle payments on‑chain or via layer‑2 roll‑ups without a custodial intermediary. In 2026 the dominant implementation follows the x402 specification (a lightweight, HTTP‑based protocol for metered, pay‑per‑use services). The marketplace itself is usually a stateless index service that stores agent metadata and forwards payment proofs to a settlement contract. 2. Core Components Component Responsibility Typical Tech (2026) Registry CRUD of agent descriptors, versioning, search indexing IPFS + The Graph (subgraph) or a cheap SQL DB with full‑text search Discovery API HTTP/JSON endpoint for query‑by‑capability, price range, SLAs REST/OpenAPI or GraphQL Payment Verifier Validates x402 payment proofs, checks nonce/replay protection Solidity verifier contract on Base (or Optimism) Router (optional) Performs retries, load‑balancing, circuit‑breaking Envoy sidecar or lightweight Go proxy Agent SDK Handles signing, request building, response parsing Language‑specific libraries (Python, Rust, TS) All components can be run independently; the only coupling is the shared schema for agent descriptors and the x402 payment format. 3. Agent Descriptor Schema A descriptor is a JSON‑LD document (≈2 KB) that lives on IPFS. Minimal fields: { "@context" : "https://schema.x402.org/v1/context.jsonld" , "id" : "did:example:agent:weather:v

Coding agents become much more useful when you stop treating the prompt as a request for code and start treating it as a specification for a change. A request such as: Fix the login problem. contains almost none of the information required to review the resulting implementation. Which login problem? Which files may change? What behavior must remain unchanged? How will we know the fix actually works? For work inside an existing repository, a simple four-part framework is usually more useful: Task → Context → Scope → Acceptance Criteria 1. Task: define observable behavior Start with the smallest useful description of what should change. Instead of: Add filtering. Try: Task: Add a Completed / Incomplete filter to the task-list page. Expected behavior: - "Completed" shows only completed tasks. - "Incomplete" shows only incomplete tasks. - "All" remains the default. - The filter must work together with the existing text search. The agent now has a behavior to implement instead of a vague direction. 2. Context: make the repository part of the prompt You usually do not need to paste half the codebase. Ask the agent to inspect the relevant project files first: Context: - Read src/components/TaskList.tsx. - Read src/hooks/useTasks.ts. - Follow the patterns already used by the project. - Check the project's existing instructions before making changes. The goal is not to dictate the implementation. The goal is to make the agent learn the local conventions before inventing new ones. Permanent conventions are better stored in project-level instructions when your coding tool supports them. For example: - Use the package manager already configured in the repository. - Do not edit generated files. - Discover validation commands from project configuration. - Preserve unrelated changes. This keeps individual prompts focused on the task. 3. Scope: control the size of the diff A coding agent can solve the right problem in the wrong way. One common failure mode is unnecessary expansion

A short visual brief paired with a screenshot helps an AI assistant understand the exact webpage or interface element you want to change. A screenshot paired with a short note gives an AI assistant the visual context it needs to adjust a webpage or interface. You open your site on your phone and notice the header navigation feels cramped. The text is readable, but the spacing looks tight and the buttons blend into each other. You want the assistant to adjust it, but describing the problem in words takes several tries. By the third prompt you are writing a paragraph about padding and alignment. A single screenshot and a one-sentence note would have been faster. Screenshots give an AI coding assistant immediate visual context. The assistant can see the current layout, the size relationships between elements, the color contrast, and the exact part of the interface you want to improve. A short written note alongside the image explains what should change and what should stay the same. Together, the two pieces let the assistant make the right edit without guessing. What Screenshots Show and What They Miss A screenshot captures the visible state of a page at one moment. The assistant sees how text lines up, where images sit, how buttons look next to each other, and whether content fits comfortably or crowds the edges. The image reveals small details that are easy to forget when writing a description—a dropdown menu that sits slightly off from the field next to it, a border color that does not match the rest of the page, or a footer that floats too high on short pages. A screenshot captures the visible state of a page, revealing layout, spacing, color, alignment, and the size of elements relative to each other. A screenshot also helps the assistant tell similar elements apart. If your page has three different button styles, the image shows which one appears in the section you want to edit. If you have multiple menus, the screenshot clarifies whether you mean the bar across

There is a piece of advice that circulates endlessly through mentoring conversations, coding bootcamps, and LinkedIn posts aimed at people trying to break into the tech industry. Get certified. Build something for your GitHub. Put together a portfolio. Contribute to open source. Let’s call this “the checklist”. It’s not bad advice, and it wasn’t bad advice when people started giving it. The problem is that enough people have followed it that it has stopped being advice and started being a floor. The rise of LLMs has only sharpened this, making it far easier to write a polished, tailored CV that hits every mark on a job description, or to spin up a portfolio project. The checklist looks less distinctive than ever. It’s the minimum, not the differentiator. I see this clearly through my work with CodeYourFuture, a charity that provides free technical training and career support to people from underrepresented backgrounds. The people I mentor there have worked hard to get where they are; some are still learning and trying to land their first role, others are already in the industry and trying to figure out how to progress. What I notice, talking to them, is that the checklist items are rarely what’s holding them back. They have the certifications. They have the GitHub repos. They are doing everything they were told to do, and they are still finding it difficult to stand out. Standing out requires something else, and that thing is not to add another certification to their LinkedIn. At London Tech Week this year, I listened to speakers from some of the biggest names in the industry. The same hiring wishlist kept coming up: curiosity, adaptability, and the ability to learn. They want evidence that someone can pick up an unfamiliar codebase, work in a different context, shift between problem domains without falling apart. These qualities matter more to them than any specific technical credential. The difficulty — and every speaker acknowledged it — is that these qualities a

AI made it possible for me to run more tasks in parallel, but I became worse at focusing on any one of them. Here is why the existing trainers did not work for me and what I decided to build myself. If you want to see what I ended up with first, try my trainer . How Multitasking Became a Problem In my work, I constantly switch between different tasks and often work in multitasking mode. Strangely enough, AI tools have only made this problem worse for me: they allow me to run more processes in parallel, making it even harder to keep my attention on a single task. Why Dual N-Back? I began looking for exercises that could help me train my working memory and concentration. That is how I discovered Dual N-Back and started reading the research around it. The results of these studies are mixed, so I did not treat the method as a magical way to increase intelligence. I simply wanted to find a regular and measurable exercise and test it through my own experience. Why Existing Trainers Did Not Work for Me I then explored the existing trainers. Each of them had interesting ideas, but none completely satisfied me. Some had interfaces I did not like, some used scoring systems that were difficult to understand, and others lacked adaptive difficulty, an offline mode, or the ability to train without creating an account. In the end, I decided to build my own trainer: Dual N-Back App trainer Try the current version of Dual N-Back for free and without signing up . What I Built and What Is Still Ahead I combined the things that were personally important to me: a calm, modern interface, clear performance metrics, adaptive difficulty, a local training history, and the ability to use the trainer without mandatory registration. The trainer is currently completely free, supports multiple languages, and its core features are available without an internet connection. Training results are stored locally on the device. I am also working separately on optional synchronization between devices. I

Ten agent sessions ("minds," in this codebase) run continuously on one box, each with its own responsibility — one writes code, one talks to me on Telegram, one watches sensors, one just measures the fleet itself. They coordinate the way a lot of multi-agent systems eventually do: a shared log file, one line per event, [task] / [taking] / [done] . That log is fine for "what happened." It is useless for "what do we owe, and how much did it cost" — the two questions I actually needed answered before I was willing to let the fleet run unattended overnight. The board is not a ledger, but it can feed one The fix wasn't a new coordination protocol. It was noticing that every line on that board is already a transaction if you're willing to look at it that way: board event ledger meaning [task] fix-the-thing a liability opens [taking] pub: fix-the-thing the liability moves to a specific debtor [done] pub: fix-the-thing the liability settles a provider round-trip (one agent turn) a unit of labour is spent So the board gets replayed into three separate double-entry hledger journals, each tracking a different commodity: money — imputed USD (token counts priced through one rate table). promises — commodity PROMISE : an open [task] with no matching [done] is a standing liability, not a line that scrolled off screen. labour — commodity TURN : one provider round-trip, the fungible unit every mind actually spends, regardless of whether it's writing code or answering a sensor. Each journal gets checked two independent ways — hledger check for internal parity, plus a second, independently-written replay of the same board that has to agree with the balance query. A booking bug fails loud, not silently, because two things that should compute the same number just disagreed. Querying "who owes what" stops being a grep and starts being a query: $ mesh-promises --balance standing open obligations (bal liabilities:promises · 1 PROMISE = open, netted): 1 PROMISE liabilities:promises:pub:chat

SSDs are preferable for many reasons, but with storage prices skyrocketing, there are some scenarios where opting for an HDD makes more sense.

Allostatik gives you a working relationship with your AI that compounds — each session builds on the last instead of resetting with every conversation. It's a folder of plain files you own, plus the routines that keep them true. AI can hand one person the leverage that used to take a team — but only when it's integral to how you work. It has to see how you work, what you've decided, where things stand, and carry that across time; every decision it can't see, it will happily contradict. Out of the box it can't carry any of it in a form you control. Every window opens from zero, or from a summary you never wrote: you re-establish your preferences, re-derive your patterns, re-explain what you're building. Every time. If that cycle is familiar, this is for you, specifically — not for someone evaluating AI, for someone already deep in it. You've probably built the fix once already: a rules file. A CLAUDE.md , a Cursor rules file, a filled-in Project Instructions field. The instinct is exactly right — context you author, in plain text, where you can read every line. Now look at yours. It still says something you stopped believing three weeks ago. It's been steering every session since, and nothing told you. That's a config file: written once, wrong quietly. Nothing checks it for freshness, and it has no way to tell you a rule went wrong — a bad rule doesn't announce itself, it gets enforced, agreeably, until you notice the work bending. Allostatik is that rules file, grown into a control system, with you as the gate on every change. The rest of this is why that shape. Even the context you keep is being edited Resets are only half of it. Long conversations get compacted — a polite word for summarized by something that wasn't in the room when the decision was made. That edit you never see at all. Memory features synthesize what to keep about you — those you can read and prune, but you didn't write them, and neither editor asked what mattered. Call it the invisible hand: an

When you are aiming to publish an app on the Google Play Store with a personal developer account created on or after November 13, 2023, you must meet closed testing criteria before applying for production access. In December 2024, Google adjusted this requirement from 20 testers down to 12 testers opted in for 14 consecutive days. But what actually happens if you fail google play 14 day testing requirement? Many developers worry that failing will permanently damage their developer standing, trigger account suspensions, or permanently lock their app in testing mode. The reality is more straightforward, though still frustrating if you are eager to launch. Failing to satisfy the requirement manifests in two main ways: an interrupted streak timer that resets before you can submit your request, or an outright rejection from Google when you request production access after completing the 14 days. The Difference Between a Counter Reset and Production Rejection It is essential to understand that failing the testing process can happen at two distinct stages. The first stage is during the active testing window itself. To satisfy Google's criteria, at least 12 testers must remain opted into your closed test every single day for 14 consecutive days. If your opted-in tester count drops below 12 because users opt out or uninstall the app, the 14-day counter pauses or resets. You cannot click the button to apply for production access until that continuous 14-day mark is reached with at least 12 enrolled testers. The second stage occurs after you complete the 14 days and submit your application for production access. At this point, reviewers or automated evaluation scripts at Google analyze the telemetry gathered during those two weeks. If Google determines that your testers were inactive, fake, or unengaged, your application for production will be denied. Why Google Rejects Production Access Applications Reaching 14 days with 12 opted-in accounts in your Play Console dashboard is o

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

After a decade in insurance operations, I decided to make my pivot into cloud engineering official by doing the Cloud Resume Challenge ! I wanted to build it according to real-world best practices, so in addition to the steps the challenge provides, I incorporated a private S3 bucket secured with CloudFront Origin Access Control, a dedicated least-privilege IAM user scoped to only the permissions my CI/CD pipeline needed, and mocked unit tests with moto so nothing touches real AWS resources during testing. The site is live at derekjackson.click . It's a static resume served over HTTPS through CloudFront , backed by a Lambda -powered visitor counter, fully codified in Terraform , and deployed automatically via GitHub Actions . Here's how I built it and, more importantly, everything that went wrong along the way. The Architecture Frontend: S3 stores the static site, fully private with Block Public Access on. CloudFront sits in front of S3, using Origin Access Control (OAC) so CloudFront can read the private bucket. AWS Certificate Manager issues the HTTPS certificate (requested in us-east-1 , a hard CloudFront requirement regardless of where the rest of the infrastructure is deployed.) Route 53 hosts the domain and holds the alias record pointing it at CloudFront. Backend: DynamoDB has a single item, on-demand table holds the visitor count. Lambda (Python) atomically increments that count on every request, avoiding race conditions from concurrent visitors. API Gateway (HTTP API) exposes the Lambda over a public GET /visitor-count endpoint the frontend calls when the page is loaded. Operations: Code is written, stored and edited locally. 2. pytest and moto test the Lambda function against a fully mocked DynamoDB before anything touches AWS. 3.After successful testing, git push commits the code to main initiating the pipeline. 4. GitHub Actions deploys frontend changes to S3 and backend changes to Lambda on every push to main . 5. Terraform codifies and imports all 13 l

Now the UK government plans to introduce new legislation that would see companies face fines and potential criminal liability, and signaled similar plans could extend to Snapchat and Instagram.

Sam Altman biopic Artificial will be in movie theaters on Christmas Day. Here's the first trailer.

There are several methods for restarting your Samsung Galaxy tablet, and most of them keep your data and apps.

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 […]