App Sandbox creates Windows 11 VMs without Hyper-V

https://github.com/jamesstringer90/appsandbox https://x.com/tom_doerr/status/2069685035272212627/photo/1

Jack Dorsey put 1.3 million dollars into it.

Vitalik Buterin gave it 128 ETH.

You have never heard of it.

It is called SimpleX. It is a messenger. It does not need a phone number. It does not need an email. It does not need a username. It does not need a user ID.

Not a hidden ID. Not a hashed ID. None at all.

Signal needs your phone number. WhatsApp needs your phone number. Telegram needs your phone number. Every messenger you have ever called "private" knows the one thing your bank, your stalker, and your country use to identify you.

SimpleX knows nothing.

It was built by Evgeny Poberezkin, a London-based engineer. Before this he wrote Ajv, the JavaScript validator that runs in 300 million downloads every month. He could have built anything.

He built the messenger with no users on the server.

Here is the trick.

Every other messenger gives you an identity. SimpleX gives you a connection. Each chat is its own one-way pipe. The server never sees who you are talking to. It does not even know you exist as a user.

11,327 stars. AGPL-3.0. Version 7.0 beta released two days ago.

iOS. Android. macOS. Windows. Linux. Free.

A 4-person team in London is the last line of defense between your conversations and every government, every advertiser, and every database breach.

The most private messenger ever built is the one you have never heard of.

(Link in the comments)

If you are learning System Design in 2026,

This is the BEST place to start: https://x.com/swapnakpanda/status/2069992065937907789/photo/1

Captures IMSI numbers of nearby cellphones using an SDR receiver

https://github.com/Oros42/IMSI-catcher https://x.com/tom_doerr/status/2069734954267729983/photo/1

Installs iOS apps directly to devices without the App Store

https://github.com/Lakr233/AssppWeb https://x.com/tom_doerr/status/2070127664296296564/photo/1

Hermes /learn explained.

agents usually learn the hard way.

they struggle through a task live, fail a few times, find the path that works, and only then write down what they figured out. the lesson costs you a painful session before it becomes reusable.

Hermes Agent by Nous Research just shipped /learn, and it removes that struggle from the front.

point it at a source and it builds a skill before it has ever run the task. a local SDK directory, a docs URL, a workflow you just walked it through, or a procedure you paste in as plain notes.

it reads the material, writes a 𝗦𝗞𝗜𝗟𝗟.𝗺𝗱, tests the skill live, and saves it.

so /learn an internal REST client, tell it to focus on auth and pagination, and you get back a skill that covers exactly that, ready to invoke as a slash command.

here is the part worth understanding. Hermes already created skills on its own.

after a complex task or a recovery from a dead end, a background pass would quietly capture what it learned. that loop only fires on completed work, so it learns from trajectories the agent has already finished.

/learn is the deliberate version. you invoke it, and it learns from material the agent has never touched. docs it has not read, a repo it has not run, someone else's runbook.

the mechanism is the cleanest part. there is no separate ingestion engine.

/learn builds a standards-guided prompt and hands it to the agent as a normal turn. the agent gathers the material with tools it already has, then authors the skill and saves it through the same skill tooling.

because it is just a turn, it works everywhere the agent does. the CLI, the messaging gateways, the dashboard, with nothing new to deploy.

the advantages stack up from there.

→ onboarding collapses to one command. a private API that meant re-reading the docs every session becomes a skill your whole team invokes.

→ a repo turns into a playbook. point /learn at a codebase and it captures the patterns and workflows, so the next session starts from how to work with it.

→ a one-time walkthrough becomes repeatable. deploy the staging server once, /learn it, and the procedure outlives the session.

→ the output is verifiable. every skill ships with a verification section and gets tested live before saving, so you get a draft that already ran.

memory remembers facts. skills remember how to do the work.

/learn is the front door to the second one, and it lets you fill that store on purpose instead of waiting for the agent to earn each entry the hard way.

the best builders stopped re-teaching the agent the same procedure every session. they hand it the source once and keep the skill.

That said, if you’re looking to set up Hermes, I wrote a full deep dive covering the Hermes agent’s architecture, memory system, self-evolving skills, GEPA optimization, and how to set up multiple specialized agents.

The article is quoted below.

You can also watch my YouTube crash course on the Hermes agent: https://www.youtube.com/watch?v=bNp6YcKBLgY