Pinned Tweet
I spent years cooking for people who said, “Anything is fine.”
It never was.
So I’m building Mate’s Table—turning your taste into an agent, because a 4.7-star rating still has no idea what you want for dinner.
matestable.com
Ethan Walkrman retweeted
I built an entire AI Marketing Campaign Studio with Teamily AI 2.0
But the real game changer? I turned the entire workflow into a reusable Loop
Here's how it worked:
→ Market Research Agent analyzed the target audience
→ Ad Creative Strategist developed the campaign direction
→ Social Media Strategist created the content strategy
→ Review Agent identified issues before human approval
Then I changed the target audience from startup founders to small business owners
Instead of starting over, I ran the same Loop again
The agents updated the research, messaging, and campaign strategy using shared context
One workflow, multiple specialized agents, and far less manual coordination
This is what AI-native collaboration looks like with Teamily AI 2.0
Try it and save your own workflow as a Loop
🔗 teamily.ai/i/CN6XXY
@Teamily_AI
Ethan Walkrman retweeted
Introducing TOBIRA MCP.
Bring design references into your AI coding workflow. Find inspiration, explore how it works, and give your AI more to build on.
tobirastudio.com
As always, looking to connect with people building with AI: designers, developers, and indie makers. What are you working on? 👇
AI Twitter is holding another funeral for the agent harness.
They have confused a diet with a death.
Your agent harness is not dying, it is just losing its bloat.
Harness distillation only kills off generic behavioral patches, while leaving behind the core product infrastructure that is much harder to replace.
Stable work habits belong in the model weights, while your live environment belongs in the harness.
1/
The Harness Zero paper proved that models can absorb general work habits, jumping a small 9B model from 23.3% to 44.3% task success.
Yet look at the hilarious amount of machinery it took to get there.
Researchers used Kimi K3 to build a heavy harness, then hired GPT 5.6 Sol as a full time tutor to correct the small model step by step inside a minimal loop with a Bash tool.
They needed a massive training harness just to prove you need less runtime scaffolding.
3/
The best insight from the paper is how that small model actually learned.
Training it on the giant model's perfect runs gave zero improvement, because watching a genius do calculus does not teach a ninth grader how to pass algebra.
What worked was letting the small model try a step and making tiny fixes right when it drifted.
That means the logs where your harness intercepts a bad move are secretly your most valuable training asset, which is the exact same trick Perplexity used to cut tool call failures by 21%.
3/
Even with clever training, only general procedures transferred cleanly.
Habits like inspecting files before editing, verifying results before finishing, and avoiding risky commands apply everywhere, so they compress nicely into weights.
Chemistry told a much messier story, where the distilled model hit 30% while the harnessed version reached 38%.
You cannot easily bake an external molecule validator and strict domain rules into a small model's intuition.
4/
Context management is even harder to push into weights.
Managing context means deciding what the model sees, remembers, and drops between turns.
That is not a behavior a model can simply imitate during training, because it controls the exact information the model uses to act in the first place.
You can train better judgment into a brain, yet you still have to build the memory plumbing around it.
5/
We see this exact reality from the opposite angle on ARC AGI 3.
Preserving reasoning state and compacting old context pushed GPT 5.6 Sol from 13.3% to 38.3% while using six times fewer output tokens, and Gemini 3.8 Flash jumped 3.4x just by swapping to a smarter state harness.
Nobody gave those models a new brain, they just built better plumbing to manage the working state.
6/
If the harness keeps changing, you might be tempted to let an AI automatically evolve it for you, which is another trap.
Google's RRSI paper showed that unconstrained auto tuning crushes the training tasks and then falls flat on unseen benchmarks, landing within a single point of the original untouched harness.
Automated evolution just overfits to yesterday's bugs unless you do the boring bookkeeping of tracking cost, diffs, and net gains for every single change.
7/
For 99% of product teams, model labs will handle the weight distillation while you own the system boundaries.
Stop treating temporary prompt patches like permanent architecture.
Whenever a new model ships, unplug your harness components one by one and rerun your evals.
Anthropic's Opus 5.5 guide tells you to delete old prompts about thinking carefully because the model does that natively now, while adding new harness timers to keep long runs from quitting early.
8/
Harness distillation is not the end of harness engineering, it is a much needed cleanup of the job description.
Let the next base model absorb the generic coaching.
Keep your engineering effort focused on your business rules, permissions, APIs, and context state, because nobody else has the data to build that infrastructure for you.
Jake Voytko wrote a great piece arguing that while software feels bloated today, nineties software was actually horrible.
He points out a real math problem: if AI helps us write ten times more code without cutting our error rate by ten times, apps just get buggier.
Yet that math only holds true if we keep using AI like it is 2024. Nostalgia for the nineties is a delusion, and blaming AI for bad code misses the real shift. The cure for messy software is not going backward. It is being much more ambitious.
1/
People romanticize nineties software because shipping on physical floppy disks supposedly forced high standards.
In reality, Windows 95 leaked memory until it blue screened, strategy games crashed if the computer built a 256th soldier, and a nine year old could bypass lock screens with three keys.
Today we have a different dysfunction. Most engineers treat AI like an intern, copying crash logs into a chat box one by one and pasting the fix back. When you act like a human conveyor belt, you just produce mediocre code faster.
2/
Claude engineering lead Felix Rieseberg recently pointed out that what holds developers back is not model capability, but being afraid to ask for more.
For months, he also fed crash reports to AI one at a time. Then he raised his altitude. He gave the model direct access to crash telemetry, mapped version numbers to code commits, and spun up Windows, Mac, and Linux sandboxes so it could reproduce bugs on its own. He stopped asking AI to fix individual crashes and told it to keep the app crash free.
3/
Think about how wild that shift is compared to the nineties.
In the old days, a bad joystick driver on a floppy disk could nuke your whole operating system, and losing three hours of unsaved work was a rite of passage.
Today, a model's ceiling is determined by the working environment you put it in. If you trap an agent inside a chat window, you get chat window slop. If you give it isolated machines, raw logs, and real compilers, it starts acting like an autonomous reliability team.
4/
The second trap is asking AI to roleplay.
Telling a model to act like a brilliant systems architect just upgrades its vocabulary while keeping amateur methods.
Real depth means demanding the exact tools and raw data that top specialists use, while setting targets that sound unreasonable.
If your app takes ten seconds to load, do not ask for five seconds. Ask for two hundred milliseconds, give the model a profiler and a database, and tell it the target is completely solvable.
5/
Nostalgic developers love to say AI could never match nineties legends like John Carmack writing low level code.
Look at what Linus Torvalds just did this month. Two years ago, the Linux creator called AI ninety percent marketing.
Two weeks ago, he pushed a kernel branch built with Claude Code that reworks the Linux page cache using lockless reads. Across eight threads, his patch cuts processor cycles per read from 2950 down to 725, tripling small read throughput to thirty million reads per second.
Torvalds did not stop at speed. He also pointed the model at a tricky kernel library and uncovered three bugs that had been hiding in plain sight since 2013. He still measured the regressions himself, flagged memory tradeoffs, and took full human responsibility for the code.
That is what real depth looks like. You do not ask AI to write another bloated web wrapper. You use it to attack low level bottlenecks that human teams have been too busy to touch for a decade.
6/
What about Voytko's warning that ten times more code means ten times more bugs?
Rieseberg has a golden rule for this: never let a model grade its own homework.
A single AI session will happily write buggy code and then write a weak test that says the code passed. You need an external referee or ten adversarial threads trying to break the draft.
Better yet, AI is making the ultimate referee practical for everyday engineering: mathematical formal verification.
7/
For decades, mathematically proving that software cannot crash was way too expensive for normal companies.
Building the famous seL4 microkernel took two person years, while writing its mathematical proof took twenty.
Last week, researchers at Anthropic and Theorem used Claude to generate 180 million lines of formal mathematical proofs across 123 open source libraries down to assembly code. While writing those proofs, the model caught deep bugs that had survived trillions of traditional test runs.
We are watching the unit of software trust shift from hoping a test passes to proving the math holds. Add range by bringing in methods from outside fields, like making agents investigate your system logs the way a forensic accountant hunts fraud.
Nineties software was a fragile world of scratched CDs and manual disk defragmenters.
Stop wishing we still coded like it was 1998, and stop prompting like it is 2024. Build a bigger sandbox, demand real proof, and be more ambitious.
bitlog.com/2026/10/27/softwa…
You can read my previous article and watch the full interview in Stop Using Claude Like It Is 2024 with Felix Rieseberg, which explains how upgrading an agent's workspace and raising your ambition transforms modern software engineering.
xitter.cf/ethanwalkerman/status/…
I post every day.
Engagement stays low.
I’ve been buried in building and posting, barely engaging with anyone.
Starting today I’m going to reply more and actually connect.
Anyone else ready to connect instead of just building?
Why is AI-generated language so hard to understand? There is a widespread sense that AI-generated text has recently become harder to understand, even when the ideas themselves are not complex.
Researchers compared model output with paraphrases of the same ideas. The originals often used more rare word combinations, stacked nouns, and long gaps between related words.
So the problem is not just in your head. The wording itself can make reading harder.
The team then tested compression.
They penalized a model for using more tokens. It learned to prefer shorter grammar, even when people would choose the clearer option. The habit spread to untrained constructions.
But compression does not mean that the whole answer is short. A model can repeat itself and write a long answer, while still packing each sentence too tightly. Verbosity and compression happen at different levels.
That is why we should not train models only to be correct or to use fewer tokens. We also need to reward clear communication.
Test the output with human readers. Reward sentences that people can understand on the first read, even if that takes an extra word or two.
If we want models to write for people, human understanding has to be part of the training goal.
Which would you choose: a model that gets the job done, writes great code, and is concise, or one that is easy to understand?
arxiv.org/abs/2610.29162
Andrej Karpathy said AI coders assume instead of asking, write 1,000 lines when 100 would do, and quietly change code you never asked them to touch.
Multica turned that into a CLAUDE.md file. It’s now one of the most-starred repos on GitHub — 225K stars.
github.com/multica-ai/andrej…
The 4 rules:
1. Think before coding, and ask when unsure
2. Keep it simple
3. Only change what was asked
4. Define what “done” looks like, then loop until it passes
Even the expensive tools charging multiple $200 bills and burning heavy tokens still fail the same way until you force them to follow these rules.
If you could keep only 1 of those 4, which one?
X ALGORITHM UPDATED
The first 2 hours still matter. Your Active Times heatmap already shows when your audience is around.
I made a prompt that turns it into an annotated weekly posting calendar using the 3:2:1 rule.
Full Article and prompt in the first reply.
X ALGORITHM UPDATE 🚨
X just stopped cutting new posts first, and that should help small accounts (I check it daily with Claude and share updates worth sharing with you)
tl;dr:
- X can only check 2,800 posts each time you open your feed
- new posts used to be last in line, so they got cut first
- now everything gets cut equally, new posts included
- posts labeled low quality or misinfo now show a warning, and people can't like, reply or share them
- no score changes this time
lesson learned: your new posts now get a fair chance to be seen. Your first 2 hours still matter most.
full details:
- How it worked until this week
Every time someone opens For You, X collects around 3,700 posts it could show them: posts from people they follow, popular posts, posts liked by similar people, and brand new posts.
But X only has time to check 2,800 of them.
So it just took the first 2,800 in line. Brand new posts were at the back of the line. When there were too many, they were the ones left out... and a post that never gets checked can't be shown.
- What changed
Now everything gets cut by the same amount. 25% too many? Every type of post loses 25%, new posts included. Nobody goes first.
- Why small accounts should care
Those brand new posts are under 2 hours old, with under 8 likes and under 500 views. That's where most posts from smaller accounts are.
My read: they now get a fair chance instead of being cut first. How often X actually hits the 2,800 limit isn't in the code, so I can't tell you how big the difference is.
- Low quality and misinfo posts now show a warning
If X labels your post as low quality or misinformation, people who don't follow you see a warning on it, and they can't like, reply, repost, bookmark or share it. The code doesn't say what gets a post that label.
Here's a recap of what you should be doing:
- a new post gets its extra push only in its first 2 hours and first 200 views, so post when your people are online
- likes carry more weight than ever at 0.66 each
- people sticking around pays, the time-spent score is 50% higher than two weeks ago
- a read of 10+ seconds after someone opens your post adds 0.4
- the boost favors the post with the best like rate from its first viewers
- accounts up to 50K can get one fresh original lifted to roughly 16th
- nothing beats a copy link share, it scores 20
- replies, quotes and DM shares each score 5
- talk with your mutuals, replies between you score 20 instead of 5
- originals are the only posts that travel outside your follower base
- the 1st and the 32nd like each open a new route to strangers
- your 2nd post in the same feed is worth 62% of the first, so pick your best one
- videos still need 10+ seconds to qualify for the video lists
- earning a follow adds 4
- a pinned post with a bad link can flag the account for 7 days, worth a quick check
What you should NOT be doing:
- posts that get labeled low quality or misinfo now carry a warning, and nobody outside your followers can like or share them
- video alone won't carry you, an open counts 0.02 and the watch 0
- hide-worthy posts cost more, "not interested" sits at -52.27
- a post at 3am burns its 2 hour window before anyone sees it
- a tap that turns into a bounce is worth only 0.3
- replies and reposts don't get past your followers
- insults get your post hidden from anyone who doesn't follow you
- adult media in 3 of your last 5 posts puts a label on your account
- disguised content in videos gets checked from 64 likes, harder at 512
- self-reply chains under big accounts risk being zeroed
- one account label and non-followers stop seeing you entirely
- low-rated links don't belong in your pinned post
- recycled wording can get tagged as copypasta spam
- strangers tagged plus a low quality link is a pattern X flags
- engagement bait has no size exemption
- several posts in a row end up competing with each other
- hashtag stacks add nothing
- bookmarks are still worth 0
- 48 hours in, For You is finished with a post
Instagram just announced 90-minute horizontal videos called Features. Real talk: do you actually want to watch full podcasts or shows on Instagram, or do you still go to YouTube the second something gets longer than a Reel?
Ethan Walkrman retweeted
Lauren (@poteto) just dropped a masterclass on how to actually trust your coding agents' work more.
The secret is an inverse pyramid of leverage: put most of your effort at the top, and the least at the bottom.
> Everyone is trying to fix their agents by stuffing 500 lines of rules into AGENTS.md. That doesn't work, because prompts rely on "agent judgment," which is just a polite phrase for rolling the dice.
Here is some supplements to Lauren's pyramid 🧵👇
1. Codebase Improvements (Top of the pyramid)
>> If your architecture is messy, agents won't just copy it, they will scale that mess at lightning speed.
2. Static Analysis
>> Why burn thousands of tokens explaining a rule in English when a linter or compiler can reject bad code in 5 milliseconds?
3. Prose & 4. Human Review (Bottom of the pyramid)
>> If a rule can be a linter check or a type constraint instead of a paragraph of English, move it up the pyramid. Don't review the code, design the cage.
The ultimate meta-move: don't even audit the codebase yourself. Make the agent analyze its own past failures and build its own guardrails.
Stop lecturing your bots in English, make bad code impossible to compile.
how do you trust your agents' work more? copy this post/link and give it to your @bot or agent!
1. codebase improvements: this is just good software engineering - better architecture, stronger types and invariants, clear boundaries. agents love to copy what exists and take the shortest path, so make the easy thing the right thing. categorically eliminate problems through code and you won't need to think about it again.
2. static analysis: lint rules, tests, CI, verification (eg TLA+). very token efficient ways to catch issues ahead of time.
3. prose: comments, rules, AGENTS.md, skills - anything that can't be enforced and requires agent judgment. use it minimally, but do use /create-verification-skill.
4. human review: the hardest to scale. at the rate agents land code, it's pretty much impossible to thoroughly review every PR, so spend that effort on the highest leverage point, designing an environment where agents do the right thing by default.
this forms an inverse pyramid: you want most of your effort at the top, least at the bottom. codebase improvements are deterministic, making it more token efficient, and lets you sleep more soundly at night.
install github.com/cursor/plugins/tr… and create a new Project:
1. look through my slack/chat messages and code review comments where i've given feedback on PRs, code, architecture
2. use /recall on my past transcripts to learn how i steer agents
3. /poteto-mode use /correct and /architect on past commits to find the most common pitfalls agents fall into, then propose a plan to rearchitect the code i own so it's more agent friendly. answer open questions with prototyping rather than defer to me, and back the plan with real data.
4. before you begin, use /sharpen + /in-your-own-words and confirm this prompt with me
An O’Reilly article by Sar Haidar describes five modes of AI use that can help companies price AI products. Each mode creates different usage, costs, and value from the same subscription.
> Soloist: acts independently and produces a lot.
> Copy Paster: finishes tasks before understanding them.
> Godot Waiter: waits for AI to be ready before using it.
> Specialist: uses AI narrowly but deeply in areas they know well.
> Tourist: tries AI occasionally without developing regular use.
These are modes, not personalities. The same engineer can be a Soloist on a side project, a Specialist at work, and a Godot Waiter about production access.
So the pricing lesson is not five plans with five cute names.
1/
A seat measures access, not value. The Tourist makes adoption look broader than it is, while the Soloist and Specialist can create very different costs and results from the same plan.
Seat counts cannot tell you what value you bought.
Activity is not value either. A Soloist can produce a pile of PRs. A Specialist may use two prompts and solve the real problem.
Charge per PR or generation, and you reward motion instead of progress. Tokens can track cost. They cannot prove worth.
2/
Pricing can also help people switch modes. A bounded pilot gives a Godot Waiter evidence. A cheap first workflow gives a Tourist a reason to return. Read only access and approval steps give a Copy Paster room to learn safely.
The practical answer is often hybrid. Charge a simple base for access, meter variable agent work in units customers understand, and pool capacity with clear budget limits.
GitHub’s 2026 Copilot change follows part of this logic.
3/
Outcome pricing fits when the result is observable, attributable, and easy to define in a contract. A resolved ticket qualifies more easily than a good infrastructure change. If the result is fuzzy, do not fake certainty with a success fee.
The best pricing question is not “How many seats?”
It is “Which behavior does this price encourage?”
Design for the situation, not the stereotype. And never reward a Soloist for manufacturing work or a Tourist for showing up.
oreilly.com/radar/soloists-c…
AI builders, here is a useful test. If your product disappeared tomorrow, what could your users no longer do? If the answer is merely “get fewer answers,” you may be selling access to intelligence, not expanding what people can accomplish.
1/
Rao’s essay on cognitive mercantilism gives builders a useful shift. Ask not how much intelligence your system contains. Ask who can apply it, to which problems, and with what result. It turns cognitive abundance into product strategy, not a slogan.
The opportunity is not just smarter tools for experts. It is helping people finish work that was once beyond their skill, time, or budget. The product winner may not own the biggest hoard. It may turn the most “I wish I could” moments into “it is done.”
2/
This is not just a nice theory. In a study of 5,172 support agents, AI raised issues resolved per hour by 15%. Workers with less experience and skill gained most. The product did not just store expertise. It delivered proven practices during real work.
But access is only half the job. In a BCG experiment, consultants using AI finished suitable tasks 25% faster and produced higher quality work. On an unsuitable task, they were 19% less likely to produce correct solutions. Task fit is a feature.
3/
That means your product cannot stop at a chat box. It needs the right context, clear limits, and a sensible next action. A model can offer an answer. The product has to help someone do something with it. Completion is where the value shows up.
The demand is also wider than office automation. By July 2025, over 70% of consumer ChatGPT use was unrelated to work. Practical guidance, information seeking, and writing made up nearly 80%. Learning and deciding are not side uses. They are product opportunities.
4/
So do not start discovery by asking what the model can do. Ask what people keep postponing because help is too expensive, slow, or intimidating. That is where cheap intelligence can turn into a useful product, instead of another demo looking for a problem.
Broader use does not mean every system should do everything. Put checks where actions have consequences, and give people a clear way to verify, undo, or escalate. Safety works better as a designed path than as a velvet rope around intelligence.
5/
The roadmap may start with model capability. The scoreboard should end with user capability. Who did something they could not do before? Which problem became affordable to solve? What did they finish? Build for the moment when someone says, “I finally got it done.”
contraptions.venkateshrao.co…
Matt Pocock (@mattpocockuk) on why ADRs belong in a repo.
“ADR's are great in a repo because they're explicitly describing things that the code can't. So I think specs are bad in a repo, but ADR's are good.”
That distinction of ADR and specs or code matters even more when AI helps build the thing.
1/
The code can show which database won. It cannot tell you what lost, why it lost, or what new evidence should change the result.
ADRs, or Architecture Decision Records, were popularized by Michael Nygard. They keep the context, decision, status, and consequences.
His warning still lands: without the why, future developers can only accept a choice blindly or change it blindly.
The open source ADRs4AI project extends that idea for AI collaboration. The AI drafts the deliberation while the context is fresh.
adrs.systems/
It keeps your original words, lays out the options, makes a recommendation, and leaves a clear question for you to answer.
2/
Its bet is that human attention is now the scarce resource. AI can produce endless artifacts. You cannot reread them all.
So each question arrives ready for a decision. Accept, override, or answer in your own words. Less chat archaeology. More deciding.
Options matter more than they look. Ask for one answer and the first plausible idea can become the center of gravity.
Seeing the options side by side lets you compare tradeoffs before the recommendation turns into mental furniture.
3/
The recommendation needs an author and a rationale. Not “the AI said so.”
Which model said it, when did it say it, and what evidence did it use? A confident paragraph is not a source. It is just a confident paragraph.
Confidence also needs a because. “90% confident” is decoration if nobody explains the basis.
“High because both approaches were benchmarked on our actual workload” tells you what the confidence is made of. One is a number. The other is useful.
4/
My favorite field is the falsifier. What evidence would change this recommendation?
Not “what goes wrong if we are wrong.” That is a risk. A falsifier names the observation that should flip the choice. It gives the decision a reverse gear.
For example: “Use SQLite for the first release. If we need writes from several app servers, switch to Postgres.”
Now future you does not need to reopen the whole debate. The reopen condition is already written down.
5/
A written rationale does not make the AI correct. In one study with 199 participants, explanations alone were not enough to curb overreliance on AI.
The record should invite inspection, not manufacture agreement. The human answer is a judgment, not a rubber stamp.
Start small. One messy brain dump. One important question. One record with options, reasoning, confidence with reasons, and a falsifier.
That is ADRs4AI’s deliberative programming. Let the repo remember, so your chat does not have to.
Your agent’s memory may not need a bigger LLM. It may need fewer LLM calls with Jev.
Jev-Mem starts with a useful question: if a memory decision only needs a score or a stop signal, why generate text at all?
1/
Many pipelines ask an LLM what to link, where to search, which candidates matter, and when to stop. Then they parse the generated text back into a decision.
That is expensive ceremony for a yes or no. The model is supervising the plumbing instead of answering.
Jev-Mem gives those choices to Jev. Structured state and batched questions go in. Probabilities and choices come out.
The LLM receives the selected memories at the end and writes the answer. Less prose in the plumbing. More prose where prose is useful.
2/
The big idea is not “small models good, big models bad.”
Match the compute to the output. Code can handle exact identifiers and timestamps. A classifier can handle bounded semantic choices. The LLM can handle open ended synthesis.
On LoCoMo, the paper reports 0.777 versus 0.700 for the best baseline. Construction was 6.6× faster than the fastest rival, and query latency fell 36.7% versus the fastest memory baseline. The evidence is promising but narrow: one benchmark, an LLM judge, and no ablation.
A separate preregistered study adds useful evidence. At matched context, one Jev reranking call matched an LLM reranker within the study’s margin, at about one third of the latency.
The gain was similar selection quality at lower cost, not magic extra accuracy.
3/
On LoCoMo, reranking added 17.4 points when the answer model read 3 of 30 candidates, but 1.5 when it read 20.
The lesson: a fast scorer matters most when selection is the bottleneck. If similarity search already surfaces the evidence, extra ranking has less room to help.
With tightly matched context, that study also found one rerank call beat Jev-Mem’s multi call graph walk, 77.0% to 70.6%. At larger budgets, the ordering flipped.
More control is not automatically better. Complexity has to earn its keep.
4/
That study found another side effect. Reranking reduced correct abstention. Relevant looking context made the model less willing to say “not mentioned.”
So test whether it can still admit missing evidence. Faster retrieval should not make every answer more confident.
The practical takeaway: replace one bounded LLM decision at a time. Batch the questions, tune thresholds on your data, and watch accuracy, latency, and abstention together.
Save the LLM for synthesis. Let it write the answer, not flip every switch.
arxiv.org/abs/2609.23986
AI wearables and gadgets are getting weirdly specific. One takes your meeting notes. One journals your emotions. One wants to be your friend. Here are 9 worth knowing, without the launch hype:
1/ Amazon Bee is the affordable memory keeper. Frontier clips to your clothes or wrist, while Eclipse sticks to your phone. Both turn conversations into summaries and next steps. Perfect for anyone who has ever left a meeting thinking, what did I just agree to?
2/ Friend 2.0 is not trying to organize your life. It is trying to keep you company. The pendant listens and replies out loud, with its own name and personality. A chatty necklace, basically. It now costs $249, and permanent memory costs extra.
3/ Limitless Pendant turns conversations into searchable transcripts and summaries. The catch is availability, not the idea. Meta acquired the company and new sales ended in December 2025. A pioneer you can admire, but no longer buy new.
4/ Meta Muse Charm puts the Muse assistant in a tiny keychain gadget with a screen and an avatar called Jolly. Think Tamagotchi, except this one can help with tasks. Meta is aiming for December shipping, so it is still a preview, not a purchase.
5/ Nirva is AI jewelry for people who want to understand their day, not just record it. It turns speech and daily patterns into a journal about moods, habits, and relationships. Less meeting notes, more emotional receipts. Orders are expected to open in November.
6/ Omi is the tinkerer’s pick. Its hardware and software are open source, with apps and integrations that developers can customize. It captures conversations and turns them into summaries and tasks. Most wearables give you a product. Omi also gives you a project.
7/ Plaud NotePin is the practical meeting tool. Clip it on for interviews, lectures, or meetings, then get transcripts and structured summaries. It is the tiny intern of the group. Just note that the free plan caps transcription at 300 minutes a month.
8/ Rabbit R1 is the bright orange comeback kid. After a rough launch, updates added features like Creations, which can make small tools and games from a prompt. It is now more interesting as a pocket AI playground than as the phone replacement it first promised to be.
9/ Sandbar Stream Ring skips health tracking and focuses on thoughts. Hold its touch panel, whisper a note, and let the app organize it later. It also controls music. A smart ring for people whose best ideas arrive when their hands are busy.
Which one would you actually use after the first week?
