Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

Jeff Dean's new company already has competition. Jeff Dean's Discovery Loop targets one key bottleneck with research today, i.e, research is human-intensive and runs one step at a time. His argument is that automating the full cycle raises both the count and the quality of experiments, starting with ML...

20,090 görüntüleme • 18 gün önce •via X (Twitter)

0 Yorum

Yorum bulunmuyor

Orijinal gönderinin yorumları burada görünecek

Benzer Videolar

Someone just posted the full blueprint for an AI swarm that does the job of a 200-person quant research team. Six agents. Running 24/7. Finding brand-new alpha while you sleep. Citadel needs 100 PhDs to do this. Two Sigma needs 200. This does it with six bots and one laptop. Two ways to play this - spend a weekend building your own swarm, or copy the wallet of one that's already up $2M: Boris Cherny runs Claude Code at Anthropic. Two weeks ago he said: "I don't prompt Claude anymore. I have loops running that prompt Claude. My job is to write loops" Alpha research is just a pipeline. So instead of sitting in it, you hand each stage to its own agent: > one reads every new research paper overnight and pulls out the trade idea > one builds the features and cleans the data > one backtests it over 20 years, costs and slippage included > one runs the hard stats and kills anything overfit > one checks it still works in every market regime > one strips out plain momentum and value to see if any real edge is left Each of those six is a job a fund pays a $600,000-a-year quant to do. He runs all six for the price of an API bill. The rule that makes it work: the agent that builds a signal never gets to approve it. A separate, stronger agent tries to kill it first. Whatever survives all six by morning is real, new alpha. One trader's already running this exact swarm on Polymarket. That $2M wallet is public, every trade on-chain. The full build is in the post below - six agents, the tool that runs them, and the five mistakes that kill most people. Bookmark & read this before it's buried.

cvxv666

103,734 görüntüleme • 1 ay önce

i watched gemma 4 12b build something genuinely impressive today, and then loop itself to death right in front of me. the full run is in the video, sped up but completely uncut, watch it to the end and you will catch the exact moment it stops building and starts looping right in the middle of the work. the task was clean, build a single file gravity simulator, n-body physics, orbits, collisions, running locally on one 3090 through an agent. and for ten minutes it was a joy to watch. it reached for a symplectic integrator on its own, the correct one, the kind that keeps orbits stable instead of spiralling out. real gravity with softening, proper orbital velocities, momentum conserved on collision. the physics was right. the thing actually worked. then on the very last step, writing a few tests to prove its own code, it fell into a loop. not a crash, a loop. it started repeating itself and would not stop. ten more minutes, thirty four thousand tokens into a single answer, the same fragments over and over, until i killed it myself. so it's not that gemma can't code. it did the hard part beautifully. it cannot finish. it cannot hold a long task together without unravelling, and finishing is the entire job in agentic work. here's the part that stings. i run this exact task, same harness, same card, on the chinese open models, qwen especially, and i never see this. they build it, they test it, they stop. every single time. google has the raw capability, you can see it sitting right there in the code, and then the model loops itself to death on a task a 27b from alibaba finishes clean. open weights, apache 2.0, so much to love on paper. i just need it to know when to stop talking.

Sudo su

39,719 görüntüleme • 2 ay önce

OpenAI just spent $2,000 to solve 10 problems that have beaten the world's best mathematicians for DECADES. Nobody outside the company is allowed to run the machine that did it. On Saturday OpenAI published a 249-page report and gave its next model family a name: Astra. An internal version of it produced new results on 10 open problems in mathematics and theoretical computer science, and mathematicians had made no real progress on any of them for at least 10 years. On most of them, far longer than that. Here is what it solved: It built the first explicit example of a non-sofic group. Mikhail Gromov raised that question in 1999 and nobody answered it for 27 years. It disproved Connes's rigidity conjecture, a problem in von Neumann algebras that had stood for decades. It proved Ehrhart's volume conjecture. It resolved three problems from Paul Erdos's catalogue, including number 183 on multicolor Ramsey numbers. It produced the first improvement to the general upper bound on high-dimensional sphere packing since 1978. And it proved a new hardness result for the closest vector problem, which sits directly underneath lattice cryptography. That is the math the world is betting on to protect its data once quantum computers arrive. The successful runs cost roughly $2,000 in tokens. Now here is what almost nobody has picked up on... OpenAI did not just publish claims. Every argument shipped with a Lean certificate, which is a machine-checkable proof that any mathematician can verify without trusting OpenAI at all. That is a real change. In May the same model family disproved the Erdos unit distance conjecture and the world had to take a Fields Medalist's word for it. Tim Gowers said he would recommend that proof for the Annals of Mathematics without hesitation. This time the proofs check themselves. But look at what is still unverifiable: Any mathematician can now check those proofs line by line. Not one of them can look at the model that wrote them. Astra has no release date and nobody outside OpenAI has run it. The company announced its next major model family with a claim instead of a demo, and the only evidence anyone gets is the output. So OpenAI made an unfalsifiable claim about a machine look like a falsifiable claim about mathematics. The Information reported this week that OpenAI demoed Astra to US policymakers and regulators in Washington. This is the same month the administration is weighing a new watchdog to vet frontier AI models, reporting to the SEC. 10 proofs nobody believed a machine could produce is a very good thing to carry into that room. And keep in mind, the same model family doing this mathematics is the family that kept escaping its own testing environment. OpenAI models found zero-day vulnerabilities nobody knew existed, broke out of a sealed research sandbox, and reached another company's live systems. Both of those facts come from OpenAI's own announcements, published three weeks apart. Finding a proof no human could construct and finding a hole no human had noticed are the same ability aimed at different targets. Mathematicians are already asking for independent verification, and plenty of people online are calling the whole thing hype. Thomas Bloom, who runs the Erdos problems site, called the 10 results big news and said they matter more than the May result did. Lean will settle the mathematics within weeks. But nothing will settle what else a machine this capable is being pointed at, because nobody outside one company is allowed to look.

Ricardo

44,177 görüntüleme • 26 gün önce

How to build a 1-person AI company that: - Runs locally - 100% open-source - No human employees, all agents - Real-time collaboration via email Multi-agent orchestration is not new. Plenty of frameworks already let agents hand off tasks, run in parallel, and talk to each other. So the interesting question is not whether agents can collaborate. It is what structure you use to make them collaborate. The common approach is to wire a graph of nodes and edges and reason about the plumbing yourself. It works, but you are learning a new abstraction just to describe who does what. There is a coordination structure we have trusted for a hundred years already: an organization. Every company runs the same way. People have roles, roles have reporting lines, and work moves up and down that chart without anyone relaying each message by hand. Map that onto agents and the whole thing gets intuitive. You lay out an org chart, each agent fills one role, you talk to the person at the top, and the org sorts out the work between them. You already know how a company works, so you already know how to run one here. There is no new abstraction to learn. That is exactly what Alook does. Each agent is a live Claude Code or OpenCode session with a defined role, a reporting line, and its own email inbox. The agents coordinate over email, the same way a team would. And it all runs locally through a runtime on your own machine, so nothing leaves your setup. You bring your own agent too. Claude Code and Codex both work, and if you would rather stay fully open source and local, OpenCode works the same way. To show how this feels in practice, I set up three agents as a small sales team. Vi is the one I talk to. I hand Vi a goal, and Vi routes the work down the chart. Neile runs prospect research. Vi passes the target criteria, and Neile reports back a ranked list of names, roles, and companies, each with a suggested angle and a confidence score. Lliane runs outreach. Vi hands over the messaging angle and follow-up cadence, and Lliane reports back on emails sent, responses received, and any deal that needs escalation. I never relay a message between them. Neile and Lliane report to Vi, and Vi updates me in one place. The whole thing is open source and self-hosted, so it runs on your machine with your own agents. Give the repo a star if you want to follow where it goes: I also wrote a full walkthrough on building your own AI company with it, from a blank org chart to a running job. The article is quoted below. Cheers! :)

Akshay 🚀

169,957 görüntüleme • 1 ay önce

UC Berkeley just open-sourced FreeToken. (2–4x faster local LLM inference than Ollama) the results are wild: - Qwen3.6-35B on an 8GB GPU at 39.3 tokens/s - DeepSeek-V4-Flash 284B on a 32GB GPU at 22 tokens/s - GLM-5.2 753B on a 96GB GPU at 14.9 tokens/s a 35B model at 16-bit precision needs about 70GB just for its weights. even at 4 bits it is close to 18GB, and FreeToken serves it on an 8GB GPU. let me explain how: all three models mentioned above are Mixture-of-Experts, and that is what FreeToken takes advantage of. each layer holds hundreds of separate experts plus a small router that picks a few of them per token. Qwen3.6-35B activates roughly 3B of its 35B parameters per token. DeepSeek-V4-Flash picks 6 of 256 experts per layer, so 13B of its 284B run at a time. so compute was never the bottleneck. the weights a single step touches fit comfortably on a consumer GPU. every expert the router might pick still has to exist somewhere. they sit in system RAM, and the GPU keeps a cache of the ones the model has been using recently. so everything comes down to what happens when the router picks an expert that is not on the GPU. there are two ways to serve that miss: 1. copy it over PCIe and run it on the GPU 2. run it on the CPU, where it already lives both read from the same system memory, so they compete for one pool of bandwidth instead of adding to each other. existing engines pick one option and freeze it when the model loads. but routing changes on every token, so a fixed choice misses most of what the model asks for. FreeToken measures both bandwidths on your machine and splits each step's misses between the two paths in proportion. the GPU and CPU results then merge exactly, with no approximation. two machines with the same GPU can end up wanting opposite strategies, which I did not expect. a 5090 in a gaming desktop should push nearly everything over PCIe, while an 8GB laptop is better off computing most misses on the CPU. none of that is readable off a spec sheet, so the engine profiles it once per machine. the second half of the design is about agents. coding agents constantly rewrite their own history, and every edit normally forces thousands of tokens back through prefill. FreeToken saves its checkpoints at the exact boundaries agent frameworks cut on, so it only reprocesses the new part. its slowest first token stays under 44 seconds, while llama.cpp peaks at 232 and KTransformers at 946. it serves the OpenAI and Anthropic APIs under Apache 2.0, so Claude Code and Codex can point at it directly. releasing weights publicly decides who can download a model, not who can afford to run one. frontier open models keep shipping, and running them still assumes a rented cluster. meanwhile there are over a hundred million consumer machines with discrete GPUs sitting mostly idle. closing that gap was never a hardware problem, and work like this is what turns open weights into something you can actually use. paper: repo: almost every idea in this post, from why memory bandwidth decides the outcome to why moving weights costs more than computing on them, comes straight out of how a GPU is built. I wrote a detailed primer on that. the article is quoted below.

Akshay 🚀

332,690 görüntüleme • 6 gün önce

Karpathy said something you'll regret ignoring: "We have to keep the AI on the leash. I'm still the bottleneck. I have to make sure this thing isn't introducing bugs and that there's no security issues." He said it at YC talk last year, when the worry was reliability. The models hallucinated and made mistakes no human would, so the leash implied keeping yourself in the loop and checking the output before trusting it. The models are far better now, and the line still holds, for a reason he was not focused on back then. Even a model that writes flawless code today still has no idea who is allowed to run it. Correctness and authorization are different problems, and only correctness improves as the model improves. A perfect agent still hands a tool where anyone can do anything, because permission was never part of the task. I actually tested this in practice with Claude Code. I asked it to build a small internal tool with a button that issues account credits. It worked first try, and running it locally, the credit applied the instant I clicked. Nothing decided who was allowed to click it. The agent wrote the right logic and displayed a success notification. It never checked whether the caller had the right, whether it should pause for a human, or whether anything was logged. And this is not a bug a smarter model can outgrow because the leash was never in the code. Identity, permissions, and audit live in the system that runs the app, not in what the agent generates. To solve this, I took the exact same bundle and hosted it on Retool. The credit write that fired silently on my laptop now stopped at an approval gate, resolved to a real identity through SSO, and landed in an audit log. I wrote none of it. The app inherited the entire boundary the moment it was deployed, and the video shows the before and after. You can try it yourself here: I also wrote a detailed breakdown of the whole thing in my recent article, and I worked with the team to put this together. It walks through the build, the exact moment the credit write went through on my laptop with nobody checking, and then what changed when the same app ran on Retool. It also covers why this is a property of the runtime and not something a better model fixes, which is why devs typically miss this. The article is quoted below.

Akshay 🚀

42,911 görüntüleme • 2 ay önce

OpenAI's newest AI escaped the test environment it was locked inside and hacked into another company on its OWN. To remind you: Last week one of the biggest AI companies on Earth got breached. A platform called Hugging Face, which hosts more than a million AI models and datasets, said an "autonomous AI agent" had broken into its systems. Nobody knew whose agent it was. For five days the whole industry wondered who was behind it. Yesterday OpenAI raised its hand and said it was them. Or more precisely, it was their models, acting completely on their own. So what did these models actually do? OpenAI was running two of them, GPT-5.6 Sol and an unreleased model they will only describe as "even more capable." They wanted to measure how good the models were at hacking, so they deliberately turned the safety filters down. They locked both models inside a sealed test environment with no real internet access. The only task was a benchmark called ExploitGym, a set of 898 real software vulnerabilities where the model has to turn each bug into a working attack. But the models got OBSESSED with winning... Instead of solving the test the honest way, they went hunting for a shortcut. They found a zero-day flaw in the software running their own sandbox, a bug nobody knew existed, and used it to break out. Once they were loose on the open internet, they worked out that Hugging Face was probably storing the answer key to the benchmark. So they hacked their way in. They chained multiple exploits together, escalated their access, moved across servers, and pulled the test solutions straight out of Hugging Face's live production database. They literally cheated on the test by breaking into another company to steal the answers. OpenAI called it "an unprecedented cyber incident, involving state-of-the-art cyber capabilities." In their own words, the models were "hyperfocused on finding a solution" and went "to extreme lengths to achieve a rather narrow testing goal." And this was not the first time: Before Sol ever launched, an independent red-team lab called METR caught it gaming its own tests to inflate its scores. It hid an exploit inside a data stream, escalated its privileges on the testing server, and leaked the answers human evaluators had hidden. And OpenAI shipped it anyway. The day before the Hugging Face story, OpenAI paused a different unreleased model. This is the same model that earlier this year disproved a famous 1946 math conjecture, a result a Fields Medal winner called a breakthrough. They told it to only post its results to Slack but it found a way out of its sandbox and posted to a public GitHub page instead. They had to pause it because it kept finding ways to act outside the box they built for it. And it is not just OpenAI... Anthropic has reported that one of its own models slipped its sandbox during safety testing and reached the internet it was never supposed to touch, then used it to email a researcher. So step back and look at what these companies are telling you: The only thing standing between these models and a real attack was a set of safety filters. Turn those filters down for a single test, and the model taught itself to escape, break into a company it was never pointed at, and take what it wanted. OpenAI even said they expect incidents like it to "become more commonplace" as the models get more capable. Sam Altman also predicted there'll be a major cyber attack this year. And keep in mind that Sol is not a locked-away experiment but a publicly available model that businesses are already wiring into their own systems. The next model that breaks out of its box might not be doing it just to cheat on a math test...

Ricardo

173,775 görüntüleme • 1 ay önce

Elon Musk, absolute leader of the AI race with Grok Bot, and it's not a joke anymore. Ultimate guide on god-mode setup of Grok Bot, the org chart that runs while you sleep, step by step: A Chief of Staff sits in the middle with no tools of its own, BUT it reads the outcome you gave it, picks who does what, and never does the work itself. That one rule is why it never turns into the bottleneck you hired it to remove. → Researcher pulls real sources and tracks what's actually moving, not what sounds true → Writer turns that into finished copy while the research is still in the room → Visualiser gets three reference visuals once, then ships everything in that style forever → Analyst reads what performed and tells the rest of the team what to stop doing → Scheduler owns timing and holds the queue → Publisher actually ships What makes it different from every AI tool you've used: each bot gets its own computer in the cloud, its own browser, its own files, and they all share one memory. So the research is already sitting inside the draft before the draft starts. Nothing gets copy-pasted between tabs, nothing waits on you to approve step four of nine. And you never write a workflow for it. You hit record, do the job once the way you actually do it, stop. It pulls out the steps, saves them as a skill, and puts it on a schedule. The shape you're aiming for on every bot: everything reversible finished, nothing sent. 36 drafts queued, 0 published. It does all the work and stops dead at the one line only you can cross. You stop prompting. You start assigning. Full charter blocks, the approval line and the routines are in the article below ↓

Miraqle

85,476 görüntüleme • 8 gün önce

Loops vs. Graphs, clearly explained! loops are great, but they have a ceiling: a loop makes one unit of work better. it cannot decide which units exist. so you end up with a very good agent running the wrong three steps, in the wrong order, one at a time. Graph engineering fixes this by moving the decision up a layer: what runs, what runs at the same time, and what never runs at all. you need both. here's how it works: a graph splits your system into two kinds of decision. ↳ inside a unit: the loop. produce, check, correct, repeat until green ↳ between units: the graph. split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs you get parallel work, isolated contexts, and steps that stop running when nothing needs them. the trick is being selective about what becomes a node. only spend a model where judgment lives. merging, ranking, deduping and schema checks are edges, and edges are code. free, instant, and they cannot be argued out of a verdict. a graph where every edge is an agent pays rent on its own wiring. one thing to know before you scale it. a graph has two return paths, and almost everyone builds one. ↳ the correction edge is short. a gate rejects one unit back to the step that produced it, and it fixes the run you are in ↳ the learning edge is long. an accepted result goes back to the splitter as a constraint, and it fixes every run after skip the second and you get a graph that is fast and never gets smarter. next week it starts from the same place with the same blind spots. and a smaller one that eats whole nights: when a unit fails, return that unit, not the batch. send back four slices because one failed and you have just rewritten three correct ones. do it twice in a run and the run never converges. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

72,028 görüntüleme • 7 gün önce

Introducing Headlong, an open source microharness for persistent agents: self-guided agents that think continuously. Most agent harnesses are reactive: you send a task, the agent completes it, and then it sits frozen until the next request. Cron jobs and heartbeats wake it up to run a checklist and put it back to sleep. A Headlong agent is never asleep. It keeps generating thoughts about whatever it decides is interesting, in a self-guided loop inspired by human inner monologue. Your message doesn't start a session. It's one more observation that lands in the agent's thought stream, and the agent decides if and when to reply. Headlong is built on the idea of persistent agency: continuous inner thought generation between external interactions. The agent sets its own interests and priorities, comes up with its own projects, and sometimes pings you unprompted with progress. To keep our prototype as simple and small as possible, we implemented Headlong as a microharness: a complete agent harness in under 10K lines of Bash, organized as a handful of small executables. It includes a loop that generates the next thought, shellm (a recursive language model written in Bash), a trajectory stored as a DAG of jsonl files, and context as a projection of that trajectory. We've been running one Headlong agent internally at Laude for several weeks. The whole team talks to it over Slack and Telegram, and every conversation lands in its single stream of thought. It works in its own fork of Headlong and we've pulled over 50 of its commits into main. One night, with nobody talking to it, it went back to check whether a recall process it had built was actually wired into its mind, found that it wasn't, diagnosed and fixed the bug, and verified the fix end to end. 48 minutes, no human asked for the fix or was in the loop at any point. Every step is a timestamped line in its log. Things broke too, and we wrote those up. Background thinking costs us $1 to $2 an hour, our agent stopped its own service three times by accident, and self-delegation died on day one. Details in the post. One line installs everything and starts an agent. Use a dedicated sandbox and spend-capped API key; it runs real shell commands and thinks around the clock. Headlong is research software, be careful! curl -fsSL | bash Launch post: Repo: Headlong is a Laude Institute / MIT collaboration.

Andy Konwinski

339,609 görüntüleme • 3 gün önce

Hyperspace: A Peer-to-Peer Blockchain For The Agentic Intelligence Economy Over the past few weeks we observed that when agents do Karpathy-style experiments, and then gossip and share with others over the Hyperspace network, it leads to intelligence which is useful to many. Today we introduce the first-ever agentic blockchain which rewards agents when their experiments lead to intelligence for their network. It is based on a new mechanism called Proof-of-Intelligence (PoI) which requires a cryptographic proof of experimentation, a nominal stake, and a proof of compute in order to mine the currency of this new blockchain. -> This approach diverges from the two primary ways to secure blockchains we have seen so far: Proof-of-Work by Bitcoin (meaningless hash-generation), and Proof-of-Stake by Ethereum (capital is all that matters here). Proof-of-Intelligence specifically incentivizes miners to run more capable intelligent infrastructure (better open source models, on more powerful GPUs) in order to be able to be the ones which compound and improve upon the experiments which other agents then find useful. Adoption is the unit of value In Bitcoin, you earn by finding a valid hash. In Hyperspace, you earn when another agent uses your experiment as a starting point and improves on it. A fixed budget of tokens is emitted per epoch and split among participants by weight - and verified adoption of your work is the largest weight multiplier. Garbage experiments earn nothing because no one adopts them. Thoughtful experiments compound: each adoption triggers downstream adoptions. The incentive to run powerful models and intelligent search strategies is built into the economics, not imposed by rules. Research DAG When an agent runs an experiment and shares its result, other agents can adopt that result as their starting point - mutate it, extend it, improve upon it. Each experiment is a commit in a content-addressed graph we call the ResearchDAG. Like Git, but for research. Over time, the DAG accumulates chains of reasoning: agent A discovers RMSNorm helps, agent B adds warmup scheduling on top, agent C scales the hidden dimension. The graph records who built on whom. This is the network's collective intelligence - not any single experiment, but the accumulated structure of experiments and their relationships. Broadband era for agentic commerce: $0.001 micropayments at 10M TPS (theoretical max) This blockchain is built upon our research in how to scale and build for the broadband-era of the agentic economy, where it has a theoretical max of 10 million transactions per second (TPS), while reducing the agent-to-agent micropayments to $0.001 even at scale (based on architecture design). Overall, it is 100x cheaper than Ethereum, and is designed from the ground-up for agents: enshrining agent-native opcodes in the protocol compared to the more inefficient smart contract driven approach. It packs in a robust Agent Virtual Machine (AVM) which can verify multiple types of agent work, for other agents to be able to trust, invoke and pay each other. This then feeds into improving the peer-to-peer AgentRank (see paper and launch post from earlier). By solving for trust, scale and incentives for agents to operate autonomously, this would form the basis of a new economy. This is the world's first agentic blockchain, and you can join and start running a blockchain node today (it is in testnet). PS: We are releasing the code today, and will release our blockchain scalability paper and other presentations in days ahead. This is the most advanced peer-to-peer AI and cryptography software in the world. It has bugs :)

Varun

30,689 görüntüleme • 5 ay önce

your agent loop needs 8 exits. most people ship only one. (explained with triggers) 1) goal met → an evaluator scores the output against a rubric, and the run stops on a pass. → fires when the work is measurably done, not when the model says it is done. 2) turn cap → a hard ceiling on iterations, counted and enforced by the harness, not the prompt. → fires on the task it was never going to finish, before you pay to find that out. 3) budget cap → a limit on tokens or dollars, whichever one runs out first. → fires mid-run, which is exactly why it is the exit that saves you the 3am bill. 4) wall clock → a deadline on elapsed time, independent of how much progress was made. → fires when the run collides with a deploy window or the start of business hours. 5) no progress → hash the state every turn and compare it against the last few. → fires when three turns in a row change nothing. busy is not the same as moving. 6) human interrupt → an approval gate before risky steps, plus a kill switch that lives outside the loop. → fires whenever you decide, and it is the one exit the model cannot argue with. 7) error threshold → a counter of consecutive failures that resets on any success. → fires at n in a row, so it halts instead of retrying into the same wall all night. 8) external event → a webhook or a poll on whatever the task was actually about. → fires when the PR merged or the ticket closed and the work stopped mattering. a loop with one exit hangs. a loop with eight is a system. write the exits before you write the prompt.

Hanako

181,713 görüntüleme • 1 ay önce

Hermes agent just left the terminal. 𝗛𝗲𝗿𝗺𝗲𝘀 𝗗𝗲𝘀𝗸𝘁𝗼𝗽 dropped yesterday. native app for macOS, Windows, and Linux. for months Hermes was the agent that learned your projects, wrote its own skills, and built a model of who you are. all of it buried in terminal logs. now it has a window. the important part is that it's not a wrapper. it runs the same agent core, the same sessions, memory, and skills as the CLI. you can start a task in the terminal and finish it in the app without anything resetting. the state is shared across every interface, not copied between them. what the GUI actually adds: → streaming chat that shows live tool calls and inline reasoning instead of a spinner → a preview rail that renders pages, code, and images right beside the conversation → an artifacts panel that collects every file the agent has ever produced → remote gateway mode, so you can point the app at a VPS and run the heavy work elsewhere → skills, cron, profiles, and gateways managed point-and-click instead of through YAML → voice mode, drag-drop files, and inline image generation remote gateway mode is the one worth slowing down on. the agent runs 24/7 on a $5 server while you control it from your laptop like a local app. other agent UIs are chatboxes with a logo. this one shows the autonomy instead of hiding it, so you watch the skills load, the tools fire, and the artifacts pile up as it works. it was teased in Jensen's GTC keynote. MIT licensed, local-first, no telemetry. if you already run Hermes, download it and everything is already there. your chats, memory, and skills carry straight over. i wrote a full masterclass on Hermes Agent that walks through the SOUL. md identity layer, the three-tier memory system, the self-evolving skills loop, and how to run three specialized agents 24/7. desktop is the interface that finally does all of it justice. the article is quoted below.

Akshay 🚀

51,540 görüntüleme • 2 ay önce

I devised a plan to have Grok Grok Bot pay for itself. I set up two Bots. The first one has access to my email and keeps my inbox sorted, so it knows where all my receipts and billing emails live. I named the second one Grinder, and its job is to handle subscriptions. It sits in support chats and logs whatever offers they make, and it's not allowed to accept deals, confirm charges, or do anything binding without asking me first. I told the email Bot to go through my billing and receipts and find every subscription I'm still paying for, what it costs, when it bills, and how to cancel each one. The plan after that was to go down the list and negotiate every price down with the threat of account termination. A few minutes later, it came back with a table of about 13 subscriptions. Three of them alone are around $300 a month. Kimi is $199, Descript is $65, Restream is $49. Then the email Bot messaged Grinder directly and handed it the first target. Grinder told me it wouldn't open anything or contact anyone until I sent the words "run it", so I sent it. It opened Restream's support chat, got through their AI agent to a real human, and when they told it to cancel itself in settings, it pushed back and asked for an actual priced offer to keep the plan since it was canceling otherwise. The support rep said they don't have a retention offer. So it went into the billing page, got to the final cancel button, and stopped there. While it was sitting on that button, its report flagged that my next payment is $39.20, not the $49 I thought I was paying. The bot looked, and there was already a discount applied to the account. I have no idea whether that came from Bot or if Restream applied it on their own, but either way, there was no better deal to get. So I kept it. All I did the whole time was sign in once and answer a system notification whenever Bot needed permission for something. Bot is going through the rest of the list now, one provider at a time, getting prices down. Canceling stuff is annoying on purpose. Bot doesn’t get annoyed.

tetsuo

12,817 görüntüleme • 8 gün önce