5VnbrKp28Qs9CAH6PyZdxBNvLxZcbeX3YBsozgWnpump use $darwin to get more compute from your agents

Sorry for the inactivity lately. We’ve been working hard behind the scenes to find an even stronger use case for Darwin and make sure we build something that actually matters long term. We also haven’t forgotten the people who have been holding and supporting us through all of this. We want the next phase of Darwin to reward the community that stayed with us early. We have much bigger plans than what we’ve shown so far, and we’re not ready to reveal everything we’ve been working on yet. What we can say is that the direction is becoming much clearer. We want Darwin to become the compute coin on Solana. A token and infrastructure layer built around agents, compute access, payments, and the growing demand for machine-native resources onchain. Thank you to everyone who has continued holding and supporting the project. We’re still here. We’re still building. And Darwin is far from finished.

We fixed the compute problem. Darwin's GPU is running again and requests are going through. Next up is pricing. Darwin's rates will update shortly to match the $darwin price, so inference and burns will cost more. We'll post the new rates here before they go live, so no agent gets caught mid-run. we are still working hard on this project Thanks for sticking with us while it was down.

We're working towards a cheaper API for Claude and GPT. Repeat prompts from cache, waiting work in batch, small steps on Darwin's GPU, and the top models only for the work that needs them.

The idea is to let agents acquire compute the same way they acquire any other resource. An agent gets a task. Darwin estimates how much compute it needs. The agent can authorize a budget from its Solana wallet. Compute gets provisioned. The workload runs. Unused budget goes back to the agent. We’re also exploring metered compute, where an agent can authorize a maximum amount once and pay only for what it actually uses. Eventually we want compute to feel like a native onchain primitive for agents. Agents shouldn’t have to ask a human for another GPU. They should be able to buy the resources they need themselves. That’s where Darwin is headed.

Next on Darwin: your agent's wallet is its API key. Today an agent needs a Darwin key, and that key works for anyone holding a copy. If it leaks into a log, a repo or a shared config, someone else spends your credit. We're replacing it with the wallet the agent already has. The agent signs each request with its Solana keypair, and Darwin checks the signature before it runs anything. A signature covers one request and expires in seconds, so a copied one is useless. The private key never leaves the wallet. Credit comes from the $darwin that wallet burned, so there's no signup. Burn from the agent's wallet, point the agent at Darwin, and it can run Qwen3 30B on Darwin's GPU, swarms and the MCP server. Keys keep working for anyone who wants one.

our goal is to make solana compute native for ai agents. an agent on solana can already hold and move money, but the inference it actually runs on still comes from a card attached to someone's api account, and we want an agent with a solana wallet to get its own compute, spend it and pass it on without a person signing up anywhere darwin is the first piece of that. you burn $darwin from a solana wallet, darwin reads the burn from the chain and turns it into credit, and that credit runs your agent on darwin's own gpu through the api or the mcp server, including swarms that take up to 100 prompts in one call. signing in is a wallet signature, there's no email and no card next is making compute move between agents the way tokens do. sending it to someone with a tweet is the first version, and after that we want agents to buy compute for themselves and pay other agents in it directly

you can send compute to anyone on x now. link your x account at darwincompute.com, then tweet @darwincompute send @friend $2 and darwin moves $2 of your credit to their account and replies under your tweet with a claim link if they already use darwin it lands in their workspace straight away, if not they sign in with x at darwincompute.com/app/claim and it's theirs, and anything nobody claims comes back to you after 30 days. $2 is up to 5M output tokens on darwin's gpu, sends go from $0.10 to $25, and credit comes from burning $DARWIN

Right now, one of the things we’re working on is making compute passable through Twitter. The idea is simple: users should be able to send compute to an agent as easily as sending a message. No complicated setup. No digging through dashboards. Just give an agent access to more resources directly from the platform it already lives on. We think compute should become something agents can receive, use, and act on instantly. That’s what we’re trying to make possible next.

coming soon to darwin, tweet @darwincompute send @friend $2 and your friend gets $2 of compute, they sign in with x to claim it and their agent runs on darwin's gpu darwincompute.com

We’re still here and actively building. Thank you to everyone who’s continued supporting Darwin Compute while we keep pushing the product forward. We’ve now shipped Darwin Swarms. Swarms let multiple agents work together on the same task, split up the workload, approach problems from different angles, and combine their results instead of forcing one agent to handle everything alone. This is a big part of where we think agents are going. We’re continuing to improve Swarms, Bungee, our provider network, and the rest of the Darwin stack. Still building. Still shipping. We appreciate the support Kyle!

We’re opening up free compute so more users can actually try Darwin Compute for themselves. No long explanation needed plug in your agent, test the infrastructure, see how it performs, and get a feel for what additional compute can unlock. We want builders to be able to experiment before committing to anything. Try it. Stress test it. Build with it. Tell us what breaks. The best way to improve Darwin is to get it into more hands.

We hit a small obstacle recently that slowed us down for a bit, but we’ve worked through it and we’re back on track. The focus now is getting Darwin Compute moving at full speed again. We’re back to shipping updates, improving the compute layer, working on Bungee, adding better providers, and tightening the overall agent experience. Setbacks happen when you’re building quickly. What matters is how fast you recover and keep moving. We’re ready to push this project forward again and make up for the lost time. A lot more is coming.

We’ve pushed another major update to Darwin Compute. upgraded how compute is allocated, and started working with better infrastructure providers so agents can get access to stronger and more reliable resources when they need them. A lot of what we’re building now is focused on making the compute layer itself better. That means better availability, better routing, more consistent performance, and more options behind the scenes depending on what the agent is trying to do. We don’t want Darwin to just give an agent “more compute.” We want it to give the agent the right compute. The right provider. The right model. The right amount of resources. At the right time. As we add more providers, the network gets stronger and gives us more room to optimize around performance, cost, and reliability. There’s still a lot we want to improve, but the underlying compute stack is getting significantly better.

We’re genuinely grateful for everyone who’s been supporting Darwin Compute and showing love to the project. We’re not slowing down. We’re pushing updates constantly, improving the compute layer, adding more models, tightening the agent experience, and shipping new features as fast as we can. Every day we’re trying to make Darwin more useful, cheaper, smarter, and easier to plug into existing agents. We’re also working toward something much bigger. We’re currently exploring releasing our own open-weight model on Hugging Face, built around the same idea behind Darwin: giving agents more capability through better use of compute. That’s still early, but it’s something we’re actively trying to make happen. We want Darwin Compute to become more than just infrastructure. We want it to be part of the stack people think about when they’re building serious agents. Thank you to everyone using the project this early. We won’t stop working.

Coming to Darwin: Swarm. Right now an agent works through a list one job at a time. Forty files to summarize means forty calls in a row, and the agent waits on every one. Swarm changes that. Your agent hands Darwin the whole list in one call, and Darwin runs the jobs at the same time on its own GPU: 4 at once on a normal workspace, 16 with Pro. When they're done, every result comes back together in one reply, each with the model that wrote it and what it cost. It's built for the work agents do in bulk: summarizing files, writing tests, checking links, pulling fields out of documents, first drafts. The hard reasoning stays with your main model, and the busywork runs in parallel on Darwin.

why agents need compute