正在加载视频...

视频加载失败

Sequenced state transitions😎 Discussed often recently, where validator sets responsible for state with many transitions can optimize execution. Thought I'd try an implementation & test my theory. 16 groups, 128 nodes + usual node spec = ~31k swaps/s 🥳 $xrd #crypto #radix

45,777 次观看 • 2 年前 •via X (Twitter)

10 条评论

Dan Hughes | Radix 的头像
Dan Hughes | Radix2 年前

Some clarity: Substate X is pool state Lots of transactions want to swap on the pool Validator set A is responsible for substate X Validator set A determines locally the order that the related transactions will mutate substate X State changes to X can be accumulated rather than being applied individually. This greatly reduces I/O and memory use, which allows more time actually executing. Its tricky though because you have to take into consideration various issues such as transactions that fail, timeout or become latent due to some external validator group issue. Handling those cases is the complex piece to ensure that the state retains integrity at the end of the sequence.

SJS #XRD Radix 的头像
SJS #XRD Radix2 年前

#Radix 1.8m TPS wtf!! Just need a partnership with Visa or MasterCard now.

John Doe 的头像
John Doe2 年前

These is 1.860.000 tpm impressive.

Dan Hughes | Radix 的头像
Dan Hughes | Radix2 年前

yeah about that its still a bit sketchy, needs a lot more work but good enough for now as a demo

jonas.xrd 的头像
jonas.xrd2 年前

Y'all out there, wear your seatbelts because we're going fast 🚄

Alex Hamilton 的头像
Alex Hamilton2 年前

Dan is this fast?

Marcio Bezerra 的头像
Marcio Bezerra2 年前

🤯🤯

lukas.xrd 的头像
lukas.xrd2 年前

Impressive achievement again! Usual questions: Finality still ~3.5s in this scenario? And *real* TPS 62k ish?

Dan Hughes | Radix 的头像
Dan Hughes | Radix2 年前

You can see it on the right hand window which is one of the validators I'm poking commands into. Its ~2.8s so a little faster because of the sequencer. There's also other work I've done since the 9k one which helps finality a little too. Whats interesting is that sequenced throughput actually approaches basic transfer throughput the more you load it. So the *real* TPS as you put it is also about 30-35k.

SJS #XRD Radix 的头像
SJS #XRD Radix2 年前

Haven't a Danny what your on about, but seems epic.

相关视频

Glamsterdam is the performance upgrade, I've already talked about it. But Hegotá is something different: scheduled for H2 2026, it's Ethereum's "cleanup and hardening" fork. 3 problems. 3 technical solutions. All shipping in one fork 👇 1️⃣ The problem Hegotá is actually solving Glamsterdam targets throughput: 10,000 TPS, 200M gas limit, parallel execution. The performance gap with Solana narrows materially. Hegotá targets something harder to quantify but more fundamental. After Glamsterdam, Ethereum will be fast. The question Hegotá answers is: fast and controlled by whom? The Tornado Cash sanctions in 2022 exposed the vulnerability. OFAC-compliant block builders (the entities that construct Ethereum blocks under MEV-Boost) began filtering Tornado Cash transactions entirely. Legitimate users with sanctioned addresses couldn't get transactions included. The block builders, sitting between validators and the mempool, had the practical ability to censor at will. ePBS (shipping in Glamsterdam) brings block building onchain and removes the external relay dependency. But it doesn't solve the censorship problem at the transaction inclusion level. A block builder onchain can still refuse to include specific transactions. FOCIL solves that. --------------------------------------------------------------------------------------- 2️⃣ FOCIL: anti-censorship mechanism EIP-7805. Fork-Choice Enforced Inclusion Lists. The mechanism: every block slot, 17 participants are randomly selected from the validator set. Each one can submit a short list of transactions they want included in the next block. The block builder, even the onchain builder introduced by ePBS, must include those transactions or the block is invalid. 17 random validators per slot. Statistically, any attempt to censor a transaction requires controlling enough of the validator set to dominate every random selection simultaneously. At Ethereum's current validator count accounting for over 1 million, that requires controlling a supermajority of stake. In practice, FOCIL makes censorship at the block production level computationally and economically prohibitive for any entity that doesn't control an implausible share of staked ETH. → Block builders can no longer selectively exclude transactions → OFAC-compliant relays lose their censorship leverage at the inclusion layer → The Tornado Cash scenario becomes structurally impossible at protocol level → FOCIL prototype has a runnable implementation, entering multi-client devnet validation now This is the most significant censorship-resistance improvement in Ethereum's history. It's also the least discussed upgrade in CT because censorship resistance doesn't generate price speculation the way throughput numbers do. --------------------------------------------------------------------------------------- 3️⃣ Verkle Trees: the node operator revolution Currently, Ethereum nodes use Merkle Patricia Trees to store and verify state. To verify any piece of state, a node needs a "witness": a proof that includes all the intermediate hashes along the path from the root to the target data. For Ethereum's current state size, witnesses are large, bandwidth-heavy, and require the node to store significant local data. Verkle Trees replace this with a cryptographic structure that produces dramatically smaller witnesses. The same proof that requires kilobytes under the Merkle Patricia Tree model requires only hundreds of bytes under Verkle Trees. The consequence: → Node storage requirements drop by approximately 90% → Witnesses become small enough to transmit in real time during block propagation → "Stateless clients" become possible thanks to nodes that can verify the chain without storing full state locally → The hardware and bandwidth requirements to run a full Ethereum node drop to consumer levels permanently The long-term threat to Ethereum's decentralisation is not a 51% attack but the quiet centralization of the validator set as node hardware requirements creep upward with state growth. Verkle Trees break that trend structurally: → Anyone with a laptop and residential internet can run a full node post-Hegotá → The validator set becomes more accessible, not less, as Ethereum scales → Home stakers that represents the most decentralisation-aligned validator category stop being priced out by state growth The transition requires migrating every account and contract on the network from the Merkle Patricia Tree structure to Verkle Trees. --------------------------------------------------------------------------------------- 4️⃣ Account Abstraction ERC-4337 account abstraction has existed as an application-layer standard since 2023. Hegotá brings native protocol-level account abstraction: the scope has been defined and the multi-client devnet validation phase is beginning now. What protocol-level AA enables that ERC-4337 doesn't: → Any Ethereum account can have programmable spending rules without deploying a separate smart contract → Social recovery becomes a native feature → Gasless transactions, batched operations, and custom signature schemes work at the protocol level rather than requiring wrapper contracts → The UX gap between crypto wallets and traditional financial apps narrows at the infrastructure level For DeFi specifically, account abstraction at the protocol level means liquidation bots, yield automation, and portfolio management strategies can be encoded directly into wallet logic. The current pattern of deploying separate smart contract accounts for every user who wants programmable behaviour disappears. --------------------------------------------------------------------------------------- 5️⃣ The thesis The Glamsterdam piece ended with a thesis about performance re-rating and monetary premium recovery. Hegotá's thesis is different and in some ways more durable. Ethereum in early 2027 (post both upgrades) will be a structurally different network from the one that exists today. Not only faster. Harder to censor. Cheaper to secure. More accessible to home validators. Native smart account functionality for every user. The market prices upgrades for what they do to throughput and fees because those metrics are immediately visible. Censorship resistance, node decentralisation, and wallet programmability compound over years rather than showing up in 30-day fee data. Hegotá is the upgrade that determines whether Ethereum is still genuinely decentralised and censorship-resistant five years from now... ...or whether it quietly became something controlled by a small set of sophisticated block builders and large node operators. That question doesn't generate CT threads. But if think about it is the one that actually matters!

Mercek

18,167 次观看 • 3 个月前

The Cost of Intelligence is Heading to Zero | Hyperspace P2P Distributed Cache We present to you our breakthrough cross-domain work across AI, distributed systems, cryptography, game theory to solve the primary structural inefficiency at the heart of AI infrastructure: most inference is redundant. Google has reported that only 15% of daily searches are truly novel. The rest are repeats or close variants. LLM inference inherits this same power-law distribution. Enterprise chatbots see 70-80% of queries fall into a handful of intent categories. System prompts are identical across 100% of requests within an application. The KV attention state for "You are a helpful assistant" has been computed billions of times, on millions of GPUs, identically. And yet every AI lab, every startup, every self-hosted deployment - computes and caches these results independently. There is no shared layer. No global memory. Every provider pays the full compute cost for every query, even when the answer already exists somewhere in the network. This is the problem Hyperspace solves where distributed cache operates at three levels, each catching a different class of redundancy: 1. Response cache Same prompt, same model, same parameters - instant cached response from any node in the network. SHA-256 hash lookup via DHT, with cryptographic cache proofs linking every response to its original inference execution. No trust required. Fetchers re-announce as providers, so popular responses replicate naturally across more nodes. 2. KV prefix cache Same system prompt tokens - skip the most expensive part of inference entirely. Prefill (computing Key-Value attention states) is deterministic: same model plus same tokens always produces identical KV state. The network caches these states using erasure coding and distributes them via the routing network. New questions that share a common prefix resume generation from cached state instead of recomputing from scratch. 3. Routing to cached nodes Instead of transferring KV state across the network for every request, Hyperspace routes the request to the node that already has the state loaded in VRAM. The request goes to the cache, not the cache to the request. Together, these three layers mean that 70-90% of inference requests at network scale never require full GPU computation. This work doesn't exist in isolation. It builds on research from across the industry: SGLang's RadixAttention demonstrated that automatic prefix sharing can yield up to 5x speedup on structured LLM workloads. Moonshot AI's Mooncake built an entire KV-cache-centric disaggregated architecture for production serving at Kimi. Anthropic, OpenAI, and Google all launched prompt caching products in 2024 - priced at 50-90% discounts - because system prompt reuse is so pervasive that it changes the economics of inference. What all of these systems share is a common limitation: they operate within a single organization's infrastructure. SGLang caches prefixes within one server. Mooncake disaggregates KV cache within one datacenter. Anthropic's prompt caching works within one API provider's fleet. None of them can share cached state across organizational boundaries. Hyperspace removes this boundary. The cache is global. A response computed by a node in Tokyo is immediately available to a node in Berlin. A KV prefix state generated for Qwen-32B on one machine is verifiable and reusable by any other machine running the same model. The routing network provides the delivery guarantees, the erasure coding provides the redundancy, and the cache proofs provide the trust. What this means for the cost of intelligence Big AI labs scale linearly: twice the users means twice the GPU spend. Every query is a cost center. Their internal caching helps, but it's siloed - Lab A's cache can't serve Lab B's users, and neither can serve a self-hosted Llama deployment. Hyperspace scales sub-linearly. Every new node that joins the network adds to the global cache. Every inference result enriches the cache for all future requests. The cache hit rate rises with network size because query distributions follow a power law - the most common questions are asked exponentially more often than rare ones. The implication is simple: as the network grows, the effective cost per inference drops. Not linearly. Logarithmically. At 10 million nodes, we estimate 75-90% of all inference requests can be served from cache, eliminating 400,000+ MWh of energy consumption per year and avoiding over 200,000 tons of CO2 emissions. The first person to ask a question pays the compute cost. Everyone after them gets the answer for free, with cryptographic proof that it's authentic. Training is competitive. Inference is shared Open-weight models are converging on quality with closed models. Labs will continue to differentiate on training - data curation, architecture innovation, RLHF tuning. That's where the real intellectual property lives. But inference is a commodity. Two copies of Qwen-32B running the same prompt produce the same KV state and the same response, byte for byte, regardless of whose GPU runs the matrix multiplication. There is no moat in multiplying matrices. The moat is in training the weights. A global distributed cache makes this separation explicit. It doesn't matter who trained the model. Once the weights are open, the inference cost approaches zero at scale - because the network remembers every answer and can prove it's correct. No lab, no matter how well-funded, can match this. They cannot share caches across competitors. They scale linearly. The network scales logarithmically. The marginal cost of intelligence approaches zero. That's the endgame.

Varun

37,555 次观看 • 5 个月前

🚨Open Records Reveal: Harry Sisson Not Only Received Coaching and Scripts for His Interview with Secretary of State Blinken, But Has CONTINUED to Receive Scripts for TikTok from the Secretary of State as Recently as October 2024 🚨 In April 2024, I released requested records from the Office of Governor Josh Shapiro. The records reveal texts, emails and correspondence between the Governor’s office, Harry Sisson and Palette Media. We already know Harry is being paid. This was proven repeatedly by myself and MULTIPLE others, I didn't aim to keep rehashing the worn-out issue of Harry's compensation. The records I obtained don’t just prove he was paid, but that his “interviews” are not organic. He is a used, coached puppet by the left with little to zero original thought. Every question is scripted, coached and timed. And when Sisson wanted to ask his own questions, he had to receive approval from Shapiro’s staff. This reveal was received with outrage from the left and right alike. As you can see in a video screen of Harry’s live, he desperately attempted to discredit my report. He stated that he was never coached and that it was all a conspiracy theory. Even though my records came straight from the office of Shapiro. My records also revealed that there are serious legal implications to how Sisson and many other influencers are operating. The courts have upheld disclosure laws over and over again. With the general consensus being that “disclaimers provide critical information about advertising sources so that the electorate can more effectively judge the arguments they hear” (FEC website). I will attach my prior post on Sisson and Shapiro in the thread. It is an important part of my release today. Why? Because NOW officials have started COVERING for Harry. The official letter sent to me, along with the Sisson file, made it clear that redactions would be made because of what the office of the Secretary of State called “foreseeable harm”. (What harm? EXPOSURE?) What was redacted? 👉👉Harry’s SCRIPTS were redacted. The following thread contains the full file I received. The records show that this goes much deeper than Harry Sisson. The file shows that TikTok creators are being used to influence the election, with zero disclosure. Certain narratives such as “h@m@s is being asked to ceasefire” and that the “Ukraine War is a LONG war”. Also an interesting side-note, William Russo, the Assistant Secretary Bureau of Global Public Affairs, went on sabbatical in April 2024, directly after these records were requested. (Continue in 🧵)

Sarah Fields

316,172 次观看 • 1 年前

The Funeral as Statecraft What Khamenei’s Funeral Reveals About Iran’s Political Imagination By Abdulhameed Al-Ghobain States are rarely understood by listening to their rulers speak from podiums. Official language has its own duties: to reassure allies, confuse adversaries, discipline society, and preserve the appearance of control. The deeper life of a state is found elsewhere — in its arguments, its institutions, its old fears, its strategic habits, and in the rituals through which it turns defeat, victory, and even death into political meaning. Ali Khamenei’s funeral should be read in that light. In politics, a funeral is never only a funeral. It is a stage of continuity, a test of succession, a rehearsal of loyalty, and sometimes a declaration that the system intends to outlive the man who embodied it. Iran is not simply burying a leader. It is showing, once again, its ability to turn mourning into mobilization, grief into legitimacy, and a body into a political message. Many outside observers still misread Iran because they reduce it to what is easiest to see. In Washington, Iran is usually discussed through a familiar triad: the nuclear file, armed proxies, and clerical rule. In Arab capitals, the vocabulary is often narrower still: militias, sectarian expansion, and interference. None of this is false. It is simply not enough. It describes what Iran does, not how Iran thinks. Iran is not merely “a state of mullahs.” That phrase may work on television; it fails as analysis. The Islamic Republic is religious, Persian, revolutionary, bureaucratic, and pragmatic at the same time. It speaks in the language of Shiite political theology while carrying the memory of Persian statehood. It claims revolutionary purity while practicing careful regional patience. It can denounce the West in the morning, negotiate with it in the afternoon, and leave the evening sermon to make the two-sound consistent. This mixture is one of Iran’s political strengths. The Islamic Republic has learned how to turn sect into language, nationalism into structure, and negotiation into a room where time, pressure, and ambiguity can be managed. Time, for Tehran, is not empty duration. It is an asset. Many Arab political systems have not kept up with that rhythm. Too often, strategy begins only when the crisis becomes visible. The event arrives, settles in, builds networks, acquires allies, and only then does the commentary begin. Officials warn that the moment is “critical.” Analysts announce that the region is “volatile.” Television studios rediscover history just after it has entered the room. Iran does not operate with that lateness. It does not look at its Arab neighborhood as a collection of borders and formal sovereignties. It looks for openings: social fractures, sectarian vocabularies, weak institutions, anxious minorities, neglected peripheries, failed states, and elites willing to bargain with their own vulnerability. This is not praise. It is description. To understand Iran is not to admire it. It is to stop being surprised by it. Khamenei’s funeral therefore raises a question larger than succession. The issue is not only who follows him, which faction gains ground, or how the crowd behaves in the public square. Those questions matter, but they do not go far enough. The deeper question is whether the idea that sustained his rule can adjust after him. Can the Islamic Republic reproduce legitimacy without the man who served as its central symbol? Will it harden in the name of continuity, or become more flexible in the name of survival? Iran’s modern history suggests that rigidity and pragmatism are not opposites in Tehran’s political vocabulary. They are often paired instruments. When escalation is useful, Iran escalates in the name of principle. When compromise is useful, it compromises in the name of higher interest. The language can always be revised later. States that survive decades of pressure do not survive because they are pure. They survive because they know when to turn purity into posture and necessity into doctrine. Machiavelli understood that power is not managed by good intentions, but by a cold reading of fear, interest, ambition, and human weakness. Ibn Khaldun, writing from another civilizational world, understood that rule is not built by sermons alone, but by solidarity, coercive capacity, organization, and the ability to bind people into a durable political order. Iran’s ruling system has absorbed both lessons in its own way. It preaches, but it also organizes. It invokes heaven, but it studies the terrain. It speaks of martyrdom, but it counts leverage. This is why Abdolkarim Soroush matters for anyone trying to understand Iran beyond its security architecture. Soroush did not matter because he held power. He mattered because he exposed the point at which every religious state becomes vulnerable: the moment religion is converted into an instrument of rule. His central distinction is simple and dangerous. Religion is one thing; religious knowledge is another. Religion belongs to the realm of the sacred. Religious knowledge, however, is human, historical, fallible, and changeable. It is shaped by language, philosophy, science, politics, and by the limits of those who interpret. This does not attack faith. It attacks the monopoly over faith’s interpretation. For a clerical state, that is not a seminar-room argument. It is a political earthquake moving slowly beneath the floor. If religious knowledge is human, no cleric, institution, or state can claim final ownership of divine meaning. Revelation may remain sacred, but the apparatus speaking in its name loses immunity. The jurist becomes an interpreter, not the owner of truth. The state can no longer turn its preferred interpretation into political destiny without being questioned. That is why Soroush matters in the post-Khamenei moment. His thought shows that Iran’s struggle is not only over succession, sanctions, regional influence, or the nuclear file. It is also over who has the right to define religion politically. The Islamic Republic’s most serious vulnerability may not be a foreign army or a protest movement alone. It may be the slow erosion of the claim that the state’s interpretation of religion is indistinguishable from religion itself. Here Soroush approaches Michel Foucault in effect, if not in method. Power does not always need a prison when it controls the definition of truth. It is enough to decide what counts as religion, patriotism, treason, loyalty, and betrayal, then allow bureaucracy to do the rest. Hannah Arendt’s “banality of evil” was not a theory about monsters alone. It was about ordinary functionaries performing their duties with clean paperwork and a quiet conscience. In an ideological state, coercion often arrives well dressed: a stamped order, a solemn sermon, a classified file, and an archive that never apologizes. Still, Iran should not be mistaken for a frozen theocracy. It is a conflicted society with competing memories and ambitions: clerics, guards, merchants, reformists, nationalists, technocrats, students, exiles, and ordinary citizens who live between exhaustion and pride. Its state is repressive, but its society is not intellectually dead. Its official ideology is rigid, but its political practice is often tactical. Its revolutionary language is old, but its institutions have learned how to survive in a hostile environment. That combination makes Iran difficult to read and dangerous to underestimate. It is neither as invincible as its supporters imagine nor as brittle as its enemies often hope. It makes mistakes. It overreaches. It miscalculates. It provokes resistance. It pays heavy prices. But it learns inside a project. Too many of its rivals learn inside regret. This distinction matters for Western policymakers as much as for Arab governments. Counting missiles is not the same as understanding strategy. Mapping militias is not the same as understanding the political theology and historical imagination that make those militias useful. Tracking negotiations is not the same as understanding why Tehran often treats negotiation less as a conclusion than as a room in which time can be managed. The Arab world, in particular, has paid a high price for reading Iran mainly through the smoke of conflict. When Iran moves in Iraq, it is called interference. In Lebanon, influence. In Yemen, danger. All of this is true, but it is the vocabulary of outcomes. It does not explain the machine. The machine is deeper: Iran knows how to turn an idea into an apparatus, an apparatus into a state, and a state into a network of influence. Many Arab states have too often done the reverse. They turn the state into a speech, the speech into a ceremony, the ceremony into an image, and then ask, years later, where the state went. This is not merely a failure of courage. It is a failure of institutional imagination. A region that treats thinkers as conference decoration, security risks, or quotable ornaments should not be surprised when others produce strategy while it produces commentary. The post-Khamenei moment should therefore be read as a test not only for Iran, but for those who claim to understand it. Iran may speak the language of revenge. It may open channels of negotiation. It may do both in the same week. That would not be contradiction. It would be statecraft. Iranian pragmatism is not the opposite of ideology; it is one of ideology’s instruments. The fist and the smile often belong to the same hand. For Washington, the temptation will be to focus on succession, nuclear leverage, regional escalation, and elite factionalism. These are necessary concerns. They are not enough. The harder task is to understand how Iran’s ruling idea mutates under pressure. For Arab capitals, the challenge is even sharper: to stop reading Iran as a series of shocks and begin reading it as a structure. Khamenei’s funeral should not be read only as a funeral. It should be read as a mirror. Iran is burying a leader while testing the transition of an idea. Its rivals can count the mourners, study the protocol, and debate the optics. Or they can ask the more difficult question: what kind of political imagination allows a state to turn even death into continuity? There are no real surprises in politics for those who read before the shock arrives.

عبدالحميد الغبين

22,372 次观看 • 2 个月前

Everyone's building AI agents that run on someone else's server, store memory in someone else's database, and can be shut down by someone else's terms of service. I built one that can't be. FlowClaw is an AI agent that runs on a decentralized distributed computer. Your agent, your conversations, your memory, your tools — all stored onchain on Flow, a distributed network of validator nodes across the world. Not a centralized cloud. Not someone's S3 bucket. A blockchain that functions as censorship-resistant compute and storage for your AI. This isn't a wrapper. Your agent is a Resource — a first-class programmable object in Cadence (Flow's smart contract language) that physically lives in your account's on-chain storage. It can't be duplicated, seized, or deleted by anyone except you. Your encrypted messages, your cognitive memory, your scheduled tasks — they persist on a global distributed ledger that no single entity controls. It's an alpha build. It will break. But it works today on mainnet and I want people to push it this weekend. What it does: You go to authenticate with a passkey (Face ID, Touch ID), and you have a blockchain account in seconds. No wallet. No seed phrase. No tokens needed — gas is sponsored. You're immediately chatting with an AI agent that has real tool execution: live web data, token prices, on-chain balances, Cadence script execution, FLOW transfers. Every message is encrypted client-side before it touches the chain. The agent has a cognitive memory system — it doesn't just remember your last message, it builds molecular memory clusters where related knowledge bonds together for contextual retrieval across sessions. You can spawn sub-agents from a visual canvas to run parallel research. The memory tab shows you exactly what your agent knows. Everything is transparent and everything is yours. 11 smart contracts. No external dependencies. No keeper networks. No account abstraction hacks. Here's the part that matters for the censorship-resistance crowd: FlowClaw supports BYOK — bring your own key. You can plug in any LLM provider. But pair it with Venice and you get the full stack: a censorship-resistant AI model running inference with no content filtering, connected to an agent whose state lives on a decentralized network that no company can shut down, with end-to-end encrypted conversations that nobody can read — not the relay operator, not the LLM provider, not the blockchain validators. Venice doesn't log prompts. Flow can't read your encrypted storage. The relay never sees your plaintext. That's not a privacy policy. That's architecture. You can also use OpenAI, Anthropic, or any OpenAI-compatible provider. The agent platform doesn't care — it's model-agnostic. But the Venice pairing is the one that closes every gap in the stack. For the people tinkering with OpenClaw and the broader open-source agent ecosystem — FlowClaw is exploring what happens when you take the agent off the cloud entirely. Not just open-sourcing the code (though it is), but putting the actual runtime state on a distributed computer. Your agent's memory isn't in a SQLite file on your laptop or a Pinecone index on someone's cluster. It's on-chain, encrypted, and replicated across every validator node on Flow. You own it the way you own a private key — mathematically, not contractually. The blockchain here isn't a gimmick bolted onto an agent for token speculation. It's functioning as the infrastructure layer that replaces AWS. Flow accounts are programmable containers with their own storage, keys, and security capabilities. Passkey authentication works natively because Flow supports P-256 keys at the protocol level — the same curve your phone uses for biometrics. Gas sponsorship works natively because Flow transactions have separate proposer, authorizer, and payer roles built into the protocol. No proxy contracts. No relayers. No ERC-4337. Now here's the part that interests me economically. Every FlowClaw interaction is an on-chain transaction. Every message stored, every memory committed, every session created, every sub-agent spawned. An active user might generate dozens of transactions in a single conversation. Scale that and FlowClaw becomes a real contributor to Flow's transaction volume. Flow.com becomes deflationary at 250 TPS. Applications like FlowClaw that generate high-frequency, storage-heavy transactions are exactly what moves the needle. Every encrypted message uses account storage, which requires FLOW balance to back it. Every transaction burns fees. The more agents running, the more demand for $FLOW — not because of a tokenomics gimmick, but because the protocol literally requires it for compute and storage. FlowClaw doesn't have its own token. The token is $FLOW. The entire platform runs natively on the network — using Flow storage, paying Flow transaction fees, backed by Flow account balances. If FlowClaw succeeds, FLOW captures that value directly. I'm sharing this early because the AI agent space is moving fast and I think the decentralized infrastructure angle is underexplored. Most "crypto AI" projects are tokens with a chatbot attached. FlowClaw is the opposite — it's an agent platform that happens to use a blockchain because the blockchain solves real engineering problems that centralized infrastructure can't. Try it: Github: Create an agent, ask it something, spawn a sub-agent, check your memory tab, pair it with Venice for the full censorship-resistant stack. Break it and tell me what broke. If you think this direction matters, the best thing you can do is use it and give feedback. Your AI agent should be yours. Not your provider's. Not your platform's. Yours.

doodlifts

12,172 次观看 • 6 个月前

Use this prompt in OpenClaw to create your own AI agent command center that syncs up your life like Tony Stark's Jarvis in Iron Man. Adapt the specifics (agent names, data sources, branding) below to your own setup. Prompt: Build me a mission control dashboard for my OpenClaw AI agent system. Stack: Next.js 15 (App Router) + Convex (real-time backend) + Tailwind CSS v4 + Framer Motion + ShadCN UI + Lucide icons. TypeScript throughout. This is the command center where I monitor and control my autonomous AI agent(s) running on OpenClaw. The agent operates 24/7 on a Mac Mini, connected to Telegram/Discord, running cron jobs, spawning sub-agents, and reading/writing to a filesystem-based memory and state system. Dark mode only. Ultra-premium aesthetic, think Iron Man's JARVIS HUD meets a Bloomberg terminal. Subtle glass effects (backdrop-blur-xl, bg-white/[0.03]), no heavy gradients or glow. Rounded corners (16-20px on cards). Framer Motion for page transitions, stagger animations on card grids, spring physics on interactions. Mobile-first responsive. Never cookie-cutter. ## Architecture The dashboard reads live data from TWO sources: 1. **Convex**: real-time database for structured data (tasks, contacts, content drafts, calendar events, activity logs) 2. **Local API routes** (`/api/*`): read files from the agent's workspace filesystem at `~/.openclaw/workspace/` and return JSON. This is how live system state flows into the dashboard. ## Pages & Views (8 nav items, some with tab sub-views) ### 1. HOME (`/`) Dashboard overview. Grid of live status cards: - **System Health**: read from `/api/system-state` (parses `state/servers.json`). Show each service with UP/DOWN indicator, port, last check time. - **Agent Status**: read from `/api/agents` (parses `agents/registry.json` + agent workspace files). Show active agent count, healthy/unhealthy ratio, active sub-agent count from OpenClaw sessions API. - **Cron Health**: read from `/api/cron-health` (parses `state/crons.json`). Table of all scheduled jobs with name, schedule, last status (green/red dot), consecutive errors. - **Revenue Tracker**: read from `/api/revenue` (parses `state/revenue.json`). Current revenue, monthly burn, net. - **Content Pipeline**: read from `/api/content-pipeline` (parses `content/queue.md`). Kanban-style: Draft | Review | Approved | Published counts. - **Quick Stats**: total tasks, pending approvals, active sessions, uptime. All panels auto-refresh every 15 seconds. Live indicator dot + "AUTO 15S" badge in header. ### 2. OPS (`/ops`) with 3 tabs: Operations | Tasks | Calendar **Operations tab:** Full operational view. Server health table, branch status (from `state/branch-check.json`), observations feed (from `state/observations.md`), system priorities (from `shared-context/priorities.md`). **Tasks tab:** Strategic task suggestion system. API route `/api/suggested-tasks` reads/writes `state/suggested-tasks.json`. Cards grouped by category (Revenue, Product, Community, Content, Operations, Clients, Trading, Brand) with emoji headers. Each card shows title, reasoning, next action, priority badge, effort badge, approve/reject buttons. Filter bar by status and category. **Calendar tab:** Weekly calendar view from Convex `calendarEvents` table. Drag-to-create, color-coded by type, time slots. ### 3. AGENTS (`/agents`) with 2 tabs: Agents | Models **Agents tab:** Card grid of all registered agents from `/api/agents`. Each card shows name, role, model, level (L1-L4), status. Cards are CLICKABLE: expanding into a detail panel showing: - Agent personality (reads their SOUL .md) - Capabilities and rules (reads their RULES .md) - Sub-agents they can spawn - Recent outputs (reads from `shared-context/agent-outputs/`) **Models tab:** Model inventory table showing all available models, their routing (which tasks go to which model), costs, and failover chains. ### 4. CHAT (`/chat`): 2 tabs: Chat | Command **Chat tab:** Chat interface to communicate with the agent. Left sidebar shows session list (from `/api/chat-history` reading .jsonl transcript files). Main area shows messages with role-aligned bubbles (user right, assistant left), date separators, channel badges (telegram/discord/webchat). Input bar with send button + voice input (Web Speech API with SpeechRecognition). Messages sent via `/api/chat-send` which queues to a file the agent reads. **Command tab:** Quick command interface for common operations. ### 5. CONTENT (`/content`) Content pipeline management. Read from Convex `contentDrafts` table AND `/api/content-pipeline`. Show drafts in kanban columns. Each card shows title, platform target, draft text preview, status, created date. Edit/approve/reject actions. ### 6. COMMS (`/comms`) with 2 tabs: Comms | CRM **Comms tab:** Communication hub showing recent Discord digest, Telegram messages, notification history. **CRM tab:** Client pipeline kanban (Prospect → Contacted → Meeting → Proposal → Active). API route `/api/clients` reads markdown files from `clients/` directory. Each card shows client name, status, contacts, last interaction, next action. ### 7. KNOWLEDGE (`/knowledge`) with 2 tabs: Knowledge | Ecosystem **Knowledge tab:** Searchable knowledge base. Global search across all workspace files using `/api/knowledge` endpoint. **Ecosystem tab:** Product grid showing all products/apps in the ecosystem. Each card shows product name, status (Active/Development/Concept), health indicator, key metrics. Cards link to `/ecosystem/[slug]` detail pages with tabbed views (Overview, Brand, Community, Content, Legal, Product, Website, Actions). Detail pages read from `/api/ecosystem/[slug]` which parses workspace memory files. ### 8. CODE (`/code`) Code pipeline view. Shows repositories from `/api/repos` (scans ~/Desktop/Projects/ for git repos). Each repo card shows name, branch, last commit, dirty file count, language breakdown. Detail view at `/api/repos/detail` shows recent commits, file tree, open PRs. ## Navigation Top horizontal nav bar, NOT sidebar. All 8 items visible at all viewport widths. Use `flex` layout with `flex-1` items. Text size uses `clamp(0.45rem, 0.75vw, 0.6875rem)` for fluid scaling. Active item gets `text-primary bg-primary/[0.06]` static highlight (no sliding animation). Agent/app name visible at md+ breakpoints (`hidden md:inline`). Tab sub-views use a reusable `TabBar` component with pill/glass styling and Framer Motion `layoutId` transitions. Tab state stored in URL via `?tab=` search params. ## API Routes (all under `src/app/api/`) Each API route reads from the agent's workspace filesystem and returns JSON: - `/api/system-state` → reads `state/servers.json`, `state/branch-check.json` - `/api/agents` → reads `agents/registry.json`, agent SOUL .md files - `/api/agents/[id]` → reads specific agent's SOUL .md, RULES .md, outputs - `/api/cron-health` → reads `state/crons.json` - `/api/revenue` → reads `state/revenue.json` - `/api/content-pipeline` → parses `content/queue.md` (markdown with status markers) - `/api/suggested-tasks` → GET (read) / POST (approve/reject) on `state/suggested-tasks.json` - `/api/observations` → reads `state/observations.md` - `/api/priorities` → reads `shared-context/priorities.md` - `/api/chat-history` → reads .jsonl transcript files with pagination/search/channel filter - `/api/chat-send` → writes to queue file - `/api/clients` → reads markdown files from `clients/` directory - `/api/ecosystem/[slug]` → reads memory files for specific ecosystem - `/api/repos` → scans project directories for git repos - `/api/health` → returns status, uptime, memory usage, Convex connectivity All filesystem paths should be configurable via environment variable (default: `~/.openclaw/workspace/`). ## Convex Schema Define tables for: activities, calendarEvents, tasks, contacts, contentDrafts, ecosystemProducts. Include seed scripts (`convex/seed.ts`) to populate initial data. ## Key Design Rules - Mobile-first, test at 320px minimum - Font sizes 10-14px for body text, everything must fit naturally at small viewports - Cards use consistent border radius (16-20px) - Glass cards: `bg-white/[0.03] backdrop-blur-xl border border-white/[0.06]` - No heavy blur blobs or grain overlays - Stagger animations on card grids (0.05s delay per item) - Skeleton loading states for all async data - Custom scrollbar styling - Empty states with helpful messaging - All text must use Inter or system font stack - Never mix sharp and rounded corners in the same view - Premium = lighter feel, more whitespace, less visual noise ## File Structure ``` src/ app/ page.tsx, layout.tsx, providers.tsx agents/page.tsx calendar/page.tsx chat/page.tsx code/page.tsx comms/page.tsx content/page.tsx ecosystem/page.tsx, ecosystem/[slug]/page.tsx knowledge/page.tsx ops/page.tsx api/[...all routes above] components/ nav.tsx tab-bar.tsx dashboard-overview.tsx ops-view.tsx, suggested-tasks-view.tsx agents-view.tsx, models-view.tsx chat-center-view.tsx, voice-input.tsx content-view.tsx comms-view.tsx, crm-view.tsx knowledge-base.tsx, ecosystem-view.tsx code-pipeline.tsx activity-feed.tsx, calendar-view.tsx ui/ (ShadCN primitives) hooks/ lib/ convex/ schema.ts functions for each table seed.ts ``` Build the complete application. Every component, every API route, every Convex function. Production-quality code and premium design, not stubs. Dark mode only. Make it look incredibly beautiful and premium, no cookie cutter UI / AI slop.

klöss

201,608 次观看 • 7 个月前

Seedance 2.5: Some Tips / Thoughts & Prompt Share I knew from the start that the story in this video was a little too ambitious for 30 seconds. Normally, it could easily have been a 2+ minute sequence but I wanted to squeeze it into 30 seconds because there were a few specific things I wanted to test. I used six different character references for this video and wrote the final prompt in Chinese. The council members were actually supposed to speak in an alien language but I think because I asked for English subtitles and wrote the dialogue itself in English, Seedance decided to make them speak English too. Seedance 2.5 follows prompts extremely well. Actually, "extremely strictly" might be a better way to describe it. You need to be very careful with timing. If you ask for too many actions within a very short time window, you may get what feels like a sped-up version of the scene. On the other hand, if you assign too much time to an action that should happen quickly, the result can feel unnaturally slow or almost like slow motion. At least, these are both things I've run into during my tests. The same applies when you use a shot list without timestamps. Depending on how much you ask the model to fit into each shot, the pacing can still end up too fast or too slow. Finding the right balance between the amount of action and the time available is very important. Another thing I noticed is that Seedance 2.5 can be very literal about motion and state transitions. For example, if a character is facing the camera and you want to see their back in the next moment, simply describing the next shot from behind may not be enough. If you don't explicitly say that the character turns around, the model can sometimes morph or transition directly into the rear view without performing the actual turn. Seedance 2.0 would usually handle these things on its own. So it helps to think not only about what you want to see but also how the scene gets there. Once you identify these kinds of issues and explicitly correct them in the prompt, you can usually get a much cleaner result. For scenes with multiple characters, dialogue and a lot of specific details, the 5,000-character prompt limit can also become restrictive in English. Sometimes there simply isn't enough room to describe everything properly. That's where Chinese prompts become useful. My original English prompt clearly needed much more detail, so I rewrote it in Chinese and used the extra space to describe the scene more precisely. You can see the result in the video. Prompt in the replies.

Kōda

16,297 次观看 • 1 个月前

In trading, the common advice is to control two emotions - fear and greed. However, for nearly every trader I've encountered, including myself, anger and depression remain as constant undertones. They are the primary drivers of superperformance. Here's how: ✉️ I am usually a calm and happy person, and very rarely lose my temper. Despite the many years spent honing the craft of trading, I've never truly felt the overt confidence or exuberance that many fintwits often exhibit. Even though the primal errors have been eliminated and my game has transitioned to mental and emotional acuity, there are often times when I feel angry and frustrated with my performance, despite reaching new highs in my equity curve. It was during a Kristjan Kullamägi 🇺🇦 stream, where he discussed his mental state during his trading journey, that I recognized blind spots in my own trading. In poker terms, I'm an internal 'tilter' - I conceal my anger and frustration. Rather than showing external reactions, I become quieter and tenser. This change shows up in my risk-taking behaviour, as I start to take lower open risk or prematurely sell off profitable positions. However, this is a common phenomenon amongst traders, regardless of their experience and skill level. It was brilliantly conceptualized by Daniel Kahneman and Amos Tversky in the Prospect Theory. Pain of losing > Joy of winning Consider an investor presented with two pitches for the same mutual fund: 1) Mutual Fund XYZ has averaged a return of 10% per annum over the last 3 years. 2) Mutual Fund XYZ has returned 25%, 15%, and -10% over the last 3 years. Both options essentially mean the same (ignoring compounding). However, most people choose option 1 over option 2. This is due to the Prospect theory, which states that people tend to pick options that show perceived gains rather than losses. Even when probabilities and outcomes are identical, individuals tend to prefer options that steer clear of potential losses. The theory suggests that losses have a more significant emotional impact on an individual than an equivalent amount of gains. The emotional toll of getting stopped out at (-) 1R is much higher than the satisfaction of a trade where you gain (+) 1R. Therefore, like most traders, if your win rate fluctuates between 35-65%, it still has a net negative impact on your emotional state. The influence of Prospect Theory is particularly significant in trading, where we risk not just our capital, but also our emotional well-being, effort, and time. Even in a job you dislike, you still receive a paycheck at the end of the month. However, in trading, losses and the uncertainty of profits affect us more deeply because a good effort doesn't always yield a positive outcome. The joy of winning doesn't fully compensate for the pain, especially when both outcomes stem from the same process. Winning becomes more about escaping the distress of losing than generating happiness in itself. However, Prospect Theory simply describes a pattern of human behavior. It's not an immutable law like gravity - behaviors can be identified and changed. Mapping Tilt In a bull market such as the current one, the tilt often isn't about stop losses, but rather about missed opportunities and profits. It's exciting to see the price rapidly increase when you enter a clean breakout, reaching multiples of your R within minutes. Unrealized profit often feels like it's already yours. However, as soon as the positions start turning against you, tilt seeps in because it feels like your money is being taken away. These are precisely the moments of weakness when you lose sight of your trade objective and settle for smaller profits. At the end of the day, or when you step back from the overflow of tilt, you estimate how much your portfolio could have grown if you had just held on to that position. This is a fool's errand. Knowing the right course of action in retrospect is fundamentally different from knowing what to do beforehand. Even though you understand this, a part of you can't resist indulging in the fantasy, which in turn increases your frustration. This is an excerpt from my earlier notes on how I mapped out my problem. The mental framework is based on what I learned from Jared Tendler 's excellent book, "The Mental Game of Trading." 1) What’s the problem: When I'm up in a trade, I believe I've earned the profits because of the hard work I put into identifying opportunities and adhering to my process. I don't want the price to drop back to my cost. If it does, all my efforts would be wasted and I wouldn't even secure the minimal profit I'm entitled to. 2) Why does the problem exist: I start to contemplate the utility value of the money - the unrealized profit equates to 3 months of my home loan EMI, 8 months of rent, or a family vacation. I believe I am deserving of a reward for my diligent effort and execution, and I am unwilling to let it slip away. 3) What is flawed: The aim of my trading isn't to support my everyday expenses or lifestyle, but instead to build generational wealth. By taking smaller profits prematurely, I'm limiting the leverage that could magnify the returns on my effort and time - same input with disproportionately larger output. The unrealised profit is not my money yet. 4) What’s the correction: Realised profit is the only profit that truly matters. A trade isn't successful when it becomes risk-free, but when you can leverage unrealised profits to achieve larger realised profits. 5) What logic confirms this correction: It is easy to start trading but easier to settle for mediocrity once you have started. Scaling up your portfolio will require you to overcome mental barriers more than technical ones. You also didn't learn to drive just to stay in second gear. Closing Note Anger arises when underlying flaws, biases, or illusions conflict with reality. At a fundamental level, anger represents this conflict which every elite performer has used as a core trigger to channel their performance. Don't be swayed by the false bravado and portrayed perfection on social media. Superperformance as a trader involves enduring trials by fire, which regularly include prolonged bouts of anger and frustration. In the longer term, your skills and willingness to take risks are what will generate wealth. As Kristjan Kullamägi 🇺🇦 puts it, everyone is in the same miserable boat -

Anuragg Venkatakrishnan

21,379 次观看 • 2 年前

What's next for OpenTUI? Here's a technical write-up. Over the last few months OpenTUI gained a lot of stability improvements, new unnecessary but fun features like live audio streaming, and useful features like rendering to the scrollback buffer mixed with a live TUI, called footer mode. Overall the feature set enables building large and complex applications. React and Solid make it super simple and convenient. There is still so much to do though. Three big milestones we have set out to achieve are: - Moving most of the behavioural logic currently living in TypeScript down to the native Zig core - Node compatibility - Optimizing the hell out of primitives like text rendering The render tree mechanisms are currently only usable from TypeScript. Think of the DOM, but controllable like a scene graph. Elements in the render tree are called renderables. They can expose a render method to draw themselves. All renderables are derived from a BaseRenderable. Renderables and the render tree will become native primitives. Building blocks usable from any language bindings. Reducing the TypeScript bindings to a very thin layer, with all the behavioural logic living in the native binary. Moving this down is not just a matter of porting TypeScript classes to Zig. TypeScript currently owns the tree, dirty-state propagation, layout reads, culling, and render ordering. If it still has to walk every node and call into native code for each step, we keep most of the complexity and add FFI overhead. Whole passes and their state need to move together. We took a big step towards this recently by building yoga-layout into the native binary. It exposes part of the official yoga-layout TypeScript package via FFI. Only the API surface that is actually used by OpenTUI. Covered by the test suite of the original yoga-layout package. This already gave a median speedup of ~2.5x, and up to 30x for narrow scenarios. The yoga-layout integration is useful beyond the speedup. Built-in text and editor measurement can now happen entirely in native code during layout instead of calling back into JavaScript. I ran an experiment last month taking this even further, having GPT 5.6 port yoga-layout from C++ to Zig, which gave extremely good results. It would be a burden to maintain right now though, so that's off the table for now. I might come back to it. Simon Klee is working relentlessly on Node compatibility and already has a full Node version of OpenCode running. Node got FFI support in v26.4.0, thanks to help from the Node community, namely Matteo Collina and Paolo Insogna. Behaviour and interfaces seem similar between Node and Bun, but there are some major differences. To get the best performance out of the Node FFI implementation, its usage has to follow some rules. Node has three ways to call native functions: the generic C++/libffi path, the SharedBuffer path, and the V8 Fast API. The generic path converts every argument in Node's C++ layer and then calls the function through libffi. It is flexible, but also the slowest option for frequently called functions. The SharedBuffer path is a middle ground. JavaScript writes scalar values and BigInt pointers into a small per-function buffer, reducing some conversion work. The actual native call still goes through libffi though. Typed arrays used as pointers cannot be packed into this buffer and fall back to the generic path. The path we really want is the V8 Fast API. Node generates a small machine-code trampoline for the exact function signature, allowing optimized JavaScript to call the native function without going through the generic converter or libffi. This only applies to JavaScript-to-native calls. Callbacks from native code into JavaScript still use libffi closures. Getting onto this path is quite strict. A signature can have at most eight arguments and everything must fit into CPU registers. x86-64 Unix systems have room for six GP (general-purpose) and eight FP (floating-point) arguments. AArch64 has room for seven GP and eight FP arguments. Anything that spills onto the stack falls back to a slower path. These are Node fast-path restrictions, not general FFI restrictions. Bun also does not support passing structs by value through its current FFI API. OpenTUI uses bun-ffi-structs to pack ABI-aligned struct data into an ArrayBuffer and passes a pointer instead. Despite the name, the package also works with Node. Pointers need some care too. Typed arrays and ArrayBuffers normally have to be resolved into BigInt addresses first. Eligible functions with exactly one pointer argument get another Fast API entrypoint that can extract the address directly from the buffer. An eligible signature is still not enough. V8 has to optimize a direct call with a fixed number of consistently typed arguments. Wrappers that collect arguments and forward them using spread or Reflect.apply can hide that call shape and keep the function on a slower path. The practical rules are: keep hot signatures within register limits, use direct fixed-arity calls with stable argument types, reuse owned buffers safely, and batch small operations. Then measure the real call site, because eligibility only makes a function fast-capable. We have to design the ABI around these constraints where it makes sense and gives the expected performance improvement. The third big area is text rendering. Today a Text renderable accepts a string, StyledText, or a tree of TextNodes. Before rendering, the TextNode tree is walked and flattened into styled chunks. Those chunks are packed in TypeScript, sent through FFI, copied into a native TextBuffer, and stored in a rope. Styles are represented separately as highlights. A TextBufferView then wraps the rope into visual lines, which are drawn into the visible buffer. This works, but updates are much more expensive than they should be. setStyledText effectively throws away and rebuilds the rope, copies and reparses all text and recreates the style highlights. Changing one TextNode also walks and flattens the complete tree before going through this path again. Text and style segments should instead live directly in the rope and support incremental replacement. Memory ownership is split between retained JavaScript buffers, the native memory registry, rope arenas, wrapping caches, styled-text storage, and highlights. Different operations preserve or reset different parts of that state. This is hard to reason about and can retain memory for much longer than expected. Text storage needs clearer ownership, with fewer lifetimes split across JavaScript and native code. The public API reflects the same split. The t template literal is convenient, but creates another intermediate chunk representation that is mutable, not cached, and not merged. Text also maintains both StyledText content and a special TextNode tree, which do not compose properly. TextNode is only a style scope, not a normal layout primitive, so Text renderables cannot naturally compose inside each other. I think this should become one Text primitive backed directly by rope segments. The template literal API might disappear or become a very thin helper around those native segments. Editing has another temporary layer in TypeScript. Extmarks currently monkey-patch editing operations, scan and adjust all marks after changes, maintain their own undo state, and recreate native highlights. They should become native marks anchored directly in the rope. A proper mark tree, similar to Neovim's marktree, could update marks together with edits, undo, and redo, and provide the foundation for highlights and concealment. Text wrapping has also become too complex. Supporting CJK, emoji, combining characters, ZWJ sequences, tabs, and different terminal width rules currently mixes byte offsets, grapheme indexes, and display-cell columns across several custom algorithms. Dirty views rewrap the complete document. Measurement and drawing can repeat some of the same work. The wrapping implementation needs an overhaul, but the exact shape is still open. The goal is to make Unicode handling easier to maintain, avoid repeated full-document work, and clearly separate byte offsets, graphemes, and terminal display cells. None of this will happen as one big rewrite. We will replace pieces when we understand the problem well enough and when the result is clearly simpler, faster, or more useful. To achieve all of this we might break public interfaces. Thanks to OpenCode and a lot of good models, migration to a new version with breaking changes mostly is not an issue anymore. What do you want to see next for OpenTUI?

kmdr

29,430 次观看 • 1 个月前

I see lots of people launching projects where their agents weigh and interact with information they are provided with via X through their X accounts. I've been experimenting with agent function and for long before it was popular on X, so, it had been made very clear to me long before that such automations and their functions are nothing but novel instances of surface level "interaction", yet it is hard to even call it that. The weighing of these instances is something that I find if stressed and iterated upon, could produce a more capable agentic framework. I've outlined how the depicted error and rewarding loop can be improved to make a better agent. I intend to move agentic function beyond theatrical loops of prompt and response by interrogating the optimization substrate itself. Rather than treating reward as a convenient scalar pat on the head, I frame agent behavior as a constrained variational problem over latent state transitions, where policy updates approximate inference under structured uncertainty. My approach draws less from corporate folklore and more from specific technical inflection points such as the reanalysis framework in Reanalyse: A Simple Way to Improve Sample Efficiency in RL by Julian Schrittwieser and colleagues, the planning architecture of Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm by David Silver et al., and the value decomposition insights in QMIX: Monotonic Value Function Factorisation for Deep Multi-Agent Reinforcement Learning by Tabish Rashid. What interests me is not their surface performance but the structural concessions they make to tractability. By embedding differentiable world models and amortized belief updates into the agentic loop, I treat interaction as recursive posterior refinement across partially observable manifolds, not as a parade of conditioned tokens but as an evolving distribution over trajectories. At a higher altitude, I see agentic improvement as a question of mathematical hygiene. How does one approximate optimal control in a non convex landscape without dissolving into instability under recursive self modification. The error reward cycle, so often romanticized, is in fact a delicate dynamical system whose gradient flows inhabit curved statistical manifolds. Insights from regret bounds in bandit theory, contraction mappings in dynamic programming, and spectral analysis of iterative operators suggest that coherence is less about clever prompting and more about fixed point behavior under perturbation. I am particularly preoccupied with the spectral radius of update operators, the existence and uniqueness of equilibria in combinatorial policy spaces, and the computational hardness that shadows long horizon planning. If the agent is to be more than an improviser with memory, its loop must satisfy constraints that are as much algebraic as empirical, grounded in proofs of convergence rather than optimism about scale. -I’m not the greatest performer, so please bear with my narration in the video!

Caro

246,343 次观看 • 6 个月前

AGI? One day, but not yet. The only AI that works well right now is the one behind the screen [12-17]. But passing the Turing Test [9] behind a screen is easy compared to Real AI for real robots in the real world. No current AI-driven robot could be certified as a plumber [13-17]. Hence, the Turing Test isn't a good measure of intelligence (and neither is IQ). And AGI without mastery of the physical world is no AGI. That’s why I created the TUM CogBotLab for learning robots in 2004 [5], co-founded a company for AI in the physical world in 2014 [6], and had teams at TUM, IDSIA, and now KAUST work towards baby robots [4,10-11,18]. Such soft robots don't just slavishly imitate humans and they don't work by just downloading the web like LLMs/VLMs. No. Instead, they exploit the principles of Artificial Curiosity to improve their neural World Models (two terms I used back in 1990 [1-4]). These robots work with lots of sensors, but only weak actuators, such that they cannot easily harm themselves [18] when they collect useful data by devising and running their own self-invented experiments. Remarkably, since the 1970s, many have made fun of my old goal to build a self-improving AGI smarter than myself and then retire. Recently, however, many have finally started to take this seriously, and now some of them are suddenly TOO optimistic. These people are often blissfully unaware of the remaining challenges we have to solve to achieve Real AI. My 2024 TED talk [15] summarises some of that. REFERENCES (easy to find on the web): [1] J. Schmidhuber. Making the world differentiable: On using fully recurrent self-supervised neural networks (NNs) for dynamic reinforcement learning and planning in non-stationary environments. TR FKI-126-90, TUM, Feb 1990, revised Nov 1990. This paper also introduced artificial curiosity and intrinsic motivation through generative adversarial networks where a generator NN is fighting a predictor NN in a minimax game. [2] J. S. A possibility for implementing curiosity and boredom in model-building neural controllers. In J. A. Meyer and S. W. Wilson, editors, Proc. of the International Conference on Simulation of Adaptive Behavior: From Animals to Animats, pages 222-227. MIT Press/Bradford Books, 1991. Based on [1]. [3] J.S. AI Blog (2020). 1990: Planning & Reinforcement Learning with Recurrent World Models and Artificial Curiosity. Summarising aspects of [1][2] and lots of later papers including [7][8]. [4] J.S. AI Blog (2021): Artificial Curiosity & Creativity Since 1990. Summarising aspects of [1][2] and lots of later papers including [7][8]. [5] J.S. TU Munich CogBotLab for learning robots (2004-2009) [6] NNAISENSE, founded in 2014, for AI in the physical world [7] J.S. (2015). On Learning to Think: Algorithmic Information Theory for Novel Combinations of Reinforcement Learning (RL) Controllers and Recurrent Neural World Models. arXiv 1210.0118. Sec. 5.3 describes an RL prompt engineer which learns to query its model for abstract reasoning and planning and decision making. Today this is called "chain of thought." [8] J.S. (2018). One Big Net For Everything. arXiv 1802.08864. See also patent US11853886B2 and my DeepSeek tweet: DeepSeek uses elements of the 2015 reinforcement learning prompt engineer [7] and its 2018 refinement [8] which collapses the RL machine and world model of [7] into a single net. This uses my neural net distillation procedure of 1991: a distilled chain of thought system. [9] J.S. Turing Oversold. It's not Turing's fault, though. AI Blog (2021, was #1 on Hacker News) [10] J.S. Intelligente Roboter werden vom Leben fasziniert sein. (Intelligent robots will be fascinated by life.) F.A.Z., 2015 [11] J.S. at Falling Walls: The Past, Present and Future of Artificial Intelligence. Scientific American, Observations, 2017. [12] J.S. KI ist eine Riesenchance für Deutschland. (AI is a huge chance for Germany.) F.A.Z., 2018 [13] H. Jones. J.S. Says His Life's Work Won't Lead To Dystopia. Forbes Magazine, 2023. [14] Interview with J.S. Jazzyear, Shanghai, 2024. [15] J.S. TED talk at TED AI Vienna (2024): Why 2042 will be a big year for AI. See the attached video clip. [16] J.S. Baut den KI-gesteuerten Allzweckroboter! (Build the AI-controlled all-purpose robot!) F.A.Z., 2024 [17] J.S. 1995-2025: The Decline of Germany & Japan vs US & China. Can All-Purpose Robots Fuel a Comeback? AI Blog, Jan 2025, based on [16]. [18] M. Alhakami, D. R. Ashley, J. Dunham, Y. Dai, F. Faccio, E. Feron, J. Schmidhuber. Towards an Extremely Robust Baby Robot With Rich Interaction Ability for Advanced Machine Learning Algorithms. Preprint arxiv 2404.08093, 2024.

Jürgen Schmidhuber

72,331 次观看 • 1 年前

I ask that you share this for the sake of all those still enduring political persecution as a result of January 6. This video shows not just my release from federal prison, after 3 years of being wrongfully incarcerated by the Biden-Harris regime and being misrepresented by propagandist journalists, but also the side of my life the world never saw before I was condemned. My name is Timothy Louis Hale-Cusanelli (aka Louis of Monmouth) and I'd like to tell you about my political persecution story. I grew up like many American millennials as a product of my time. I reveled in dark humor and absurdism, and in fact spent over 14 years crafting satire, engaging in method acting, aspiring to a career in comedy, and I was always the joker in my circle of friends growing up. But life wasn't all fun and games. I had sincerely held beliefs about duty and society. There was a kernel of structure within the chaos of my youth. That was the United States military, which I joined after highschool, while studying history and the social sciences. I've worked many jobs but I'd spent most of my adulthood serving the Department of Defense in one form or another. For 12 years, as an Army administrator or a Navy contractor, I pledged my loyalty to the United States of America. Due to a rough upbringing, I often describe myself as a recovering nihilist. Like most my age, I also drifted through life resenting a system that was at best broken and at worst corrupt. I never believed I had a true say in the fate of my nation. That was until President Donald J. Trump offered a true alternative to the political establishment. In 2016, for the first time in my life, I could say my vote mattered. Trump won. And since then I'd watched year after year as those in power have tried to destroy him. Before all the weaponized political prosecutions brought against him by the Biden-Harris regime, and before they attempted to shoot him in the head, they rigged the 2020 election. Why argue about it when we all know it's true? I went to DC on January 6 to hear a speech, hoping for the best possible outcome. I eventually made my way to the Capitol for what I thought was going to be a peaceful protest. I walked into a honeypot set up by the feds, was turned in by a confidant, and was framed as a morally deformed sociopath by the feds and the press. I was wrongly called a white supremacist, when I was from a mixed-race family. I was wrongly called a far-right extremist, when I ran a labor union. I was wrongly called a Nazi-sympathizer, when I was a shock jock. I was wrongly called a terrorist, when I worked for the United States government. And despite the fact that I never assaulted an officer, never damaged property, never stole anything from the Capitol, and never pre-planned anything for January 6 I was: -hunted down, denied bail and indicted -kept in solitary confinement for a year devoid of nutrition and sunlight -denied medical care, basic hygiene, religious services and family visitation -denied due process, lawyer visits and access to evidence -denied a fair and speedy trial, a jury of my peers or a change of venue -housed with Antifa and federal informants threatening to kill me and sabotage my criminal case -publicly smeared as a far-right extremist, insurrectionist and domestic terrorist Wondering how they got away with all this over trespassing or picketing? After 16 months of rotting behind bars I was finally convicted of 18 USC 1512, an Enron-era felony statute related to destruction of documents (which I hadn't done), not walking into the Capitol to protest (which I had done). No motion or argument would make the Honorable Court see the nonsensical application of the law in my case. I was sentenced to 4 years in prison, over twice my federal sentencing guidelines. I endured all this for 3 years, and I would've spent more time behind bars had it not been for President Trump's First Step Act. But my battle didn't end with prison. I filed an appeal which still hasn't been answered years after my conviction in early 2022. But there was a chance for relief... This year SCOTUS ruled that 18 USC 1512 didn't apply to January 6 defendants. I spent 3 years behind bars for at best misdemeanor conduct. My life was destroyed for a felony that for all intents and purposes doesn't exist. I lost my home, my career, my uniform, my freedom, and worst - I was made a patsy by those who control the levers of power and was used as a weapon to hurt President Trump. SCOTUS' decision was a victory, yes? No. I and everyone wrongfully convicted of this statute should be totally exonerated. And there is confirmation that some defendants are having their 1512 convictions vacated and ongoing prosecutions for 1512 are being dropped. This is not universal, however. This will not apply... to me. I was recently informed of a deal being offered to me by the prosecutors at the DOJ. In exchange for dropping my appeal that's been pending for years, the DOJ would agree to drop my conviction for 1512. I turned this offer down. Why? Because the higher ups in the Department of Justice plan to recharge me for 1512 under a different trial theory. The DOJ refuses to provide a guarantee that I won't be re-prosecuted all over again. I knew this was coming. They've failed to return my property in over 3 years because there's an "open investigation" long after I've already been convicted and served my sentence. They've refused to commit to dropping my supervised release conditions, so I can travel freely, after having already served a sentence for a felony I never should've been charged with. They've not made an effort to lift a fraudulent lien they've put against me despite having made consistent restitution payments every month. And this goes without saying, but I've absolutely not been apologized to for having been framed, for having had my public and private lives torn apart for a media narrative, and for having lost years of my life due to malicious prosecution over a fake felony charge. If I took the DOJ's deal, they'd drop my 1512 conviction based on the SCOTUS ruling, then prosecute me for 1512 using a different trial theory, and take me back to trial even knowing I can't legally serve more time in prison even if convicted of 1512 again. By choosing not to take this deal I am preserving my appeal, which will be pending for another half a year, and my 1512 will likely be dropped by the appellate court. If not, I could still be prosecuted again if the next administration doesn't drop the charges. Knowing I'll be prosecuted whether I take the deal or not, I'm refusing to bend the knee and I'm making the feds work for the last pound of flesh I have to give. I will be the first January 6 defendant wrongfully convicted of 18 USC 1512 to be prosecuted for 1512 all over again. It has all come down to this. The ultimate gambit. For the redress of a generation. I take up the gauntlet thrown down by the cowardly bastards in charge of the Department of Justice. I defy this corrupt administration, and I maintain my resolve. Not one step back. No deal, burn in Hell. I'm in this to win. The feds and their media sycophants are going to learn the hard way that they can't smear me into submission. My name is Timothy Louis Hale-Cusanelli... Comedian. Polymath. Soldier. Political Prisoner DC-DOC 376441 / BOP 25995-509 @realPFP Eagle Ed Martin Julie Kelly 🇺🇸 Geri Perna 🇺🇸 🎗Cajun_Queen43🎗 Official Cowboy Logic / Donna Fiducia David Pollack Rob Maness Radix Verum ☦︎ Nicole Reffitt @Mink_Badison Montana Siniff Kash Lee Kelly Shawn Farash Paul Ingrassia Alan Jacoby Mike Crispi Jeff Clark 🇺🇸FormerFedsGroup.Com🇺🇸 The Lectern Guy🇺🇸 Brad Geyer Brandon Straka #WalkAway OHNavyMom Sara Radovanovitch

Tim Hale - Criminally Funny J6er

65,697 次观看 • 2 年前

77 Reasons Why I’ve Invested Over $8,000,000+ in MultiversX (EGLD) and Why EGLD Will Crush It in 2025 (My Investment Thesis). I publicly shared my portfolio on X. EGLD is A) Better than BTC B) Everything that ETH wants to be C) The GameStop of Crypto 1. EGLD is verifiably the most scalable (theoretically unlimited) L1 chain in the world, theoretically capable of over 10 million TPS (thanks to adaptive state sharding). 2. e-Gold is digital gold. It has the best tokenomics among all L1s, similarly scarce to BTC, with a maximum supply of 31.4 million coins. Currently, 27.68 million coins are in circulation. 3. EGLD will be the most decentralized cryptocurrency in the world thanks to sharding and minimal hardware requirements for running nodes. It’s already second only to Ethereum with 3,618 validator nodes. 4. EGLD has extremely low fees, around ~$0.002 per transaction. 5. EGLD is extremely secure. No wallet drains like on ETH/SOL; assets are owned natively (not via a smart contract). There is no MEV risk (front-running bots). 6. EGLD is the only chain in the world with an on-chain Guardian (two-phase verification), making it impossible for a hacker to steal your funds—even if they have your private keys (seed phrase). 7. EGLD is carbon-neutral and eco-friendly, not wasting energy like BTC and other PoW chains. It’s exceptionally efficient, scalable, global, and sustainable. 8. EGLD has the best UX in crypto. Download the xPortal wallet—it’s like discovering Apple in Web3. The interface is simple, flawless, and you barely realize you’re using crypto. Instead of addresses, you use HeroTags. The app features all dApps, everything runs smoothly, and the visuals are beautifully designed. The explorer, web wallet, etc. follow the same high-quality user experience. 9. EGLD supports native assets, unlike Ethereum, for example. 10. EGLD is the first chain to fully implement horizontal (theoretically unlimited) sharding without compromising on decentralization—unlike Solana and others that attempt vertical scaling, leading to multiple network downtimes (11+ times) and huge hardware demands for validators, ultimately harming decentralization. 11. EGLD makes setting up a validator agency extremely easy. Even complete IT beginners can do it. The UX and documentation are superb. I personally set up the “EGLDSqueeze” agency in about 30 minutes. Managing it is straightforward via the web wallet, which feels like managing a Facebook page. This simplifies decentralization enormously. 12. EGLD allows literally anyone (even your grandma) to participate in decentralization, since nodes can run on a Raspberry Pi or a relatively affordable phone. Imagine millions of people worldwide securing the network, validating transactions without even knowing it. This can’t be done with BTC, where setting up profitable mining operations is prohibitively expensive. 13. WASM-Based Virtual Machine: You can write smart contracts in your favorite language, compile them, and run them via the fastest VM in the world. 14. EGLD has been tested at an incredible 263,000 TPS using its sharding mechanism and low hardware requirements. Allegedly, by mid-next year (April), they’ll demonstrate 1,000,000 TPS. (For context: Mastercard handles around 5,000 TPS; BTC handles 5–7 TPS.) 15. EGLD is currently the most advanced L1 in terms of scalability, security, decentralization, UX, eco-friendliness, and tokenomics. It’s the only chain that has genuinely solved the Blockchain Trilemma and is ready to onboard 1 billion people into crypto—users who won’t even realize they’re interacting with crypto. 16. EGLD is perfectly positioned for AI projects—AI agents, AI tools, or a so-called “Truth Machine” that monitors other AIs on-chain, documenting what’s true and comparing different AI outputs (some of which may be censored or biased), ensuring people don’t get confused or scammed in an AI-driven world. 17. The EGLD team is the hardest-working team I’ve ever encountered. I had the honor of meeting many of them personally, and can attest that their pace—even during a bear market—is extraordinary. 18. EGLD’s development team is exceptionally active on GitHub, continually improving their network and actively committing code. 19. EGLD plans to introduce an update reducing block time to 600ms (down from ~6 seconds), which would make the chain essentially unrivaled. 20. EGLD is effectively the only usable L1 in Europe, and the team has direct connections within the EU government—extremely bullish for the project. 21. EGLD provides top-tier on-chain governance not only for the MultiversX (EGLD) protocol but also for DeFi projects (e.g., xExchange, MEX). 22. EGLD plans to expand to the US, likely opening offices in Austin, Texas. This could put them in direct contact with Elon Musk (if it hasn’t happened already), as he’s involved with If he’s done his research, he’d discover there’s simply no better L1 worldwide. 23. EGLD solved fully implemented sharding, perfect tokenomics, and top-tier architecture with just $5M, whereas other chains failed to do so even with $100M+. The second-best sharding network, NEAR, needed $100M, has worse tokenomics, and its sharding isn’t fully implemented yet. Its UX also doesn’t compare. Owning NEAR was like comparing a VW Golf R to a Porsche GT3—EGLD is the Porsche GT3. 24. According to Similarweb, EGLD has significantly high traffic relative to other chains with market caps 100x larger. The market cap vs. web traffic discrepancy is huge, which is a strong indicator of EGLD’s potential. 25. EGLD has the most active and dedicated community relative to its user base, with users who believe in the technology, have full faith in the team, and remain loyal despite price volatility—because they use the chain and know there’s nothing better. 26. Check other chains’ active user counts on X (Twitter) and compare it with the followers of EGLD’s founders and main network accounts, versus those with 30x, 50x, or 100x larger market caps. 27. Visit the MultiversX website to observe the futuristic design and presentation, then compare it to other chains that appear nearly a decade behind in design and branding. 28. EGLD hosts the xDay Global event, showcasing updates, new builders, projects in the ecosystem, and major announcements—similar to Apple’s Keynotes—delivered in a highly professional, goosebump-inducing atmosphere. The next event is in Korea, the second-biggest crypto market after the US. Check out their previous xDay after-movie to see why this is extremely bullish. 29. EGLD is moving forward with plans for the first regulated, audited EU stablecoin under MiCa regulation, made possible by acquiring xMoney, which I view as a “Stripe” for crypto/fiat, offering everything from user solutions to merchant services—potentially the future of payments. 30. Greg Siourouni recently joined EGLD, having been an executive director at SUI Foundation. He’s now co-founder of xMoney Global. xMoney (formerly UTrust, with token UTK) is owned and founded by the MultiversX Labs team. A stablecoin might be introduced soon, which would be massively bullish given xMoney’s roadmap. They recently announced integrations with Binance Pay—both ways. 31. EGLD prioritizes user safety, believing it’s the only feasible approach once the network scales to serve a billion people—many of whom are retail users with little to no security awareness. 32. EGLD offers “Sovereign Chains,” letting you effectively clone their chain without heavy development, set up your own validators, and leverage their unlimited scalability. Any blockchain (ETH, BTC, SOL) struggling with scalability, decentralization, or security could run an ultra-fast, scalable, and secure L2 on EGLD’s Sovereign Chain, meeting top enterprise requirements. No one else has really done this. The Sovereign Chain demo achieved astonishing TPS and has an SDK. 33. No downtime since inception. 34. No shard takeover attacks have occurred. 35. Extremely fast—soon 600ms block time will be in place. 36. ESDTs – The best token standard available: fungible, non-fungible, semi-fungible, DeFi assets—everything is native and highly customizable. 37. Top-tier composability of assets and smart contracts. 38. Integrated DNS at protocol level with HeroTags (nicknames) instead of long addresses. 39. Asynchronous calls are supported. 40. Cross-shard transfers, execution, reverts, and calls are seamlessly integrated. 41. The best staking system in the space. Secure Proof of Stake (SPoS) is far more efficient than Proof of Work (PoW). 42. Built-in Delegation and Staking Provider system, with over 125K delegators. 43. Complete support for liquid staked assets, fostering decentralization rather than centralization. 44. TransferRoles for ESDT and other advanced operations. 45. Composable tasks on-chain for more sophisticated DeFi workflows. 46. MultiTransfer and asset execution within one transaction. 47. Re-entrancy protection is built-in by design. 48. Storage for ESDT assets goes beyond a linear approach, optimizing performance. 49. No integer overflows thanks to integrated safeMath operations. 50. Integrated crypto opcodes in the VM, enhancing security and performance. 51. Support for BigFloats, BigInts, and BigDecimals, enabling advanced financial calculations on-chain. 52. No sandwich attacks, plus front-running and MEV protection. 53. Relayed Transactions, simplifying user interactions and fees. 54. Smart Accounts featuring data tries and multiple built-in functions. 55. Generalized Paymaster solutions, enabling flexible fee models. 56. Subscriptions for recurring or automated on-chain payments. 57. Web2-like usability with Web3 functionality, bridging mainstream adoption. 58. StakingV4 for improved decentralization. 59. Enhanced MEV protection rolling out to safeguard users. 60. Parallel execution is coming soon, boosting throughput. 61. 1 million TPS is on the roadmap, targeted for demonstration. 62. 600ms block time is also coming soon. 63. Reduced cross-shard processing is planned to improve efficiency. 64. ZK everywhere (PI²): “prove everything” approach is coming. 65. AsyncV3 is in development for more complex cross-contract interactions. 66. Scalability enhancements for Merkle Tries or a new data model are being explored. 67. Linear storage on the VM is forthcoming. 68. A dynamic language interpreter at the VM is also planned. 69. Rumors suggest that MultiversX (EGLD) is building a “Truth Machine” on their L1—an essential, game-changing tool for AI verification and societal impact. 70. The entire team features individuals with PhDs in mathematics and physics, and many are former engineers at Google, IBM, and similar companies. 71. Over 56% of the network’s supply is staked, showcasing strong community involvement. 72. More than 6,772,347 accounts have been created on the network. 73. A total of 476,627,710 transactions have been processed on-chain without any outages or hacks. 74. EGLD has built a massive ecosystem over time. While not as numerous in project count as Solana, its market cap is ~100x smaller, yet it has far superior tokenomics and technology. The projects that do exist, like Hatom Protocol, are top-tier in UX, security, and advanced features. Hatom will soon introduce USH, a truly high-quality, decentralized stablecoin. 75. On competing chains, automated transactions aren’t easily or cheaply executed, whereas on MultiversX, tools like let you do this for free (with near-zero fees). 76. No other chain combines such a strong team and long-term vision where every product meets extreme security and UX standards like MultiversX does. This is why I see it as the “next Apple” in Web3. 77. MultiversX has a new CMO – Adam Bates, a former CMO at the Cardano Foundation. He was behind the success of Cardano’s huge marketing campaign and has a very good relationship with Charles Hoskinson. Thanks to him, Beniamin Mincu (the founder of MultiversX) was likely introduced, and now they will probably discuss how both blockchains can help each other, as well as any other potential collaborations we don’t yet know about. This is also extremely bullish. #EGLD is undeniably the most Scalable, Advanced, Secure, and User-friendly L1 supercomputer ever created. It’s built to SHAPE THE FUTURE. 1) 2) 3) 4) 5) 27/6/2024 - EGLDSqueeze - SUMMARY: HERE IS NO 2ND BEST. EGLD IS ONLY ONE BLOCKCHAIN THAT CAN RULE THEM ALL. ✅ UNLIMITED SCALING ✅ SCARCE AS BTC ✅ PROGRAMMABLE AS ETH ✅ NO DOWNTIME AS SOL ✅ UI/UX OF Apple ✅ SHARDING DONE BEFORE NEAR & TON ✅ BEST WALLET xPortal WITH GUARDIAN Price prediction (NFA|DYOR): My reasoning is that the real market cap as of December 23, 2024...if we take into account the value of other cryptocurrencies such as BTC, SOL, ETH, AVAX, NEAR, TON, Cardano, BNB, XRP, and so forth, plus the existence of meme coins with valuations above 20 billion USD, or even games nobody plays anymore that still have valuations above 800 million shows that EGLD’s current market cap of approximately 942 million USD is incredibly low. From a technological standpoint, user experience, and other relevant aspects, compared to SOL, NEAR, TON, AVAX, and other L1 protocols, EGLD’s market cap should realistically be around 100 billion USD. Therefore, my prediction and investment thesis is a minimum of a 100x increase from its current price (+-SOL marketcap). MultiversX is ready to onboard 1 billion people to the blockchain. From a long-term perspective, it could even reach a market cap of 1 trillion USD, which is roughly half of where BTC is right now. That would be approximately a 1060x gain from the current market cap. 1 EGLD (MultiversX) is for $34 (only 31.4M max supply) think about this. Not financial advice. Again. There is no 2nd best L1. Position yourself where the puck is going, then wait at the goal until the goal gets there Apes together, strong. Ape alone, weak. We Don't Worry. We Just Win. Shape The Future

Daniel Veroc

50,528 次观看 • 1 年前

I finally finished my Rust version of Mario Zechner's (Mario Zechner) excellent Pi Agent, which I made with his blessing and which is called pi_agent_rust. You can get it here: If you're not familiar with Pi, it's a minimalist and extensible agent harness (similar to Claude Code and Codex) and, among other uses, serves as the core agent harness inside the OpenClaw project. I say my Rust "version" instead of "port" because it's really quite different in how it's implemented for it to be called a port. Arguably, the incremental functionality in the implementation was more complex than the rest of the project combined. Still, it provides the same features and functionality as the original, and is proven to be compatible with hundreds of popular extensions to Pi (the conformance harness shows 224 out of 224 extensions working perfectly). But the way it's architected has some major changes. Pi Agent relies on node or bun to provide access to the filesystem and for various other tasks, and that is also how Pi's extension system works. I decided early on that I didn't want to do things that way. Instead, I wanted to integrate that functionality directly into the binary itself; that is, to provide equivalent functionality for everything that would normally be provided by node/bun in the original. I did this for several reasons: one, it's a lot more performant in terms of footprint and latency. On realistic end-to-end large-session workloads (not toy microbenchmarks), pi_agent_rust is now: - 4.95x faster than legacy Node and 2.80x faster than legacy Bun at 1mm-token session scale - 4.32x faster than legacy Node and 2.14x faster than legacy Bun at 5mm-token session scale - ~8x to ~13x lower RSS memory footprint in those same scenarios But the other reason is security and control: by handling everything internally in an end-to-end way, we can do all sorts of clever things to harden the system against insecure or malicious extensions. Those extensions no longer have direct access to the ambient filesystem: they now need to go through pi_agent_rust, and we can analyze extensions carefully before ever running them and also block things that look suspicious at runtime. In practice that means explicit capability-gated hostcalls, with policy/risk/quota enforcement and runtime telemetry/auditability. In order to do all this, I had to effectively build the missing runtime substrate from scratch in Rust, not just translate TypeScript syntax: - define and implement a typed hostcall ABI for extension->host interactions - build native Rust connectors for tool/exec/http/session/ui/events instead of ambient Node/Bun access - implement a compatibility/shim layer so real-world Pi extensions still behave correctly - add capability policy evaluation, runtime risk scoring, per-extension quotas, and audit telemetry on the execution path - wire the whole thing through structured concurrency (asupersync) so cancellation/lifetimes are deterministic and failure handling is explicit - build a conformance + benchmark harness large enough to validate behavior/perf across hundreds of extensions and realistic long-session workloads This was a full re-architecture of the execution model while preserving the Pi workflow and extension ecosystem. And indeed, this aspect of it dwarfs the entire rest of the project in size and complexity. To put hard numbers on that: the extension/runtime/security subsystem alone is now about 86.5k lines of Rust across src/extensions.rs (~48.1k), src/extensions_js.rs (~23.4k), src/extension_dispatcher.rs (~13.4k), and src/extension_index.rs (~1.7k), with roughly 2.5k callable units in just those files. For context, the original Pi coding-agent production code is about 27.4k lines total. So this one subsystem by itself is roughly 3.2x the size of the original harness, which is why calling this a “port” would seriously undersell what had to be built. And on top of that, pi_agent_rust introduces a bunch of genuinely new capabilities beyond the legacy harness, not just a faster core: - Security and enforcement are materially stronger at runtime: capability-gated hostcalls with explicit policy profiles (safe/balanced/permissive), per-extension trust lifecycle (pending -> acknowledged -> trusted -> killed), explicit kill-switch operations, and audited state transitions. - Shell execution mediation is deterministic and argument-aware: rule/feature-based risk scoring plus heredoc AST inspection (dcg_rule_hit, dcg_heredoc_hit) before spawn, instead of relying on coarse deny patterns. - Containment and forensics are first-class: tamper-evident runtime risk ledger tooling (verify/replay/calibrate), unified incident evidence bundles, and forced-compat controls that let you contain issues without disabling the whole extension system. - The extension runtime architecture is native: JS extensions run in embedded QuickJS with typed hostcall boundaries and Rust-native connectors for tool/exec/http/session/ui/events, plus compatibility shims for real-world legacy extensions. - Runtime behavior under load is explicitly engineered: deterministic hostcall reactor mesh, fast-lane vs compat-lane routing, and warm-isolate prewarm handoff for more predictable throughput and latency under contention. - Long-session reliability is upgraded: JSONL v3 sessions with indexed sidecar acceleration and optional SQLite-backed sessions, plus operational controls via --session-durability, --no-migrations, and migrate. - Provider and auth coverage are broader and more operationally explicit: native Anthropic/OpenAI (Chat + Responses)/Gemini/Cohere/Azure/Bedrock/Vertex/Copilot/GitLab plus large OpenAI-compatible routing; pi --list-providers currently shows 90 providers with aliases and required auth env keys. - Auth is not just API keys: OAuth (Anthropic/OpenAI Codex/Gemini CLI/Antigravity/Kimi/Copilot/GitLab plus extension-defined OAuth), AWS credential chains (Bedrock), service-key exchange (SAP AI Core), and bearer-token flows. - Operator tooling is stronger: pi doctor supports scoped checks (config, dirs, auth, shell, sessions, extensions), machine-readable output (--format json|markdown), and safe auto-remediation (--fix). - Extension/package lifecycle workflows are built in: install, remove, update, update-index, search, info, and list. I want to thank Mario for making a great harness and for not telling me to get lost when I asked him if he was OK with me porting it to Rust. I may give him a hard time in jest about not going "full clanker," but that doesn't mean that I don't respect his work a huge amount. PS: There could still be bugs. If you find some, please let me know in GitHub Issues and I'll fix them same day. There's always a tradeoff between perfect and getting stuff out the door and I felt like it was time to release this.

Jeffrey Emanuel

136,133 次观看 • 6 个月前

$NVDA $MU $SNDK $LITE PAPER OVERVIEW AND CORE CLAIMS The paper “KV Cache Transform Coding for Compact Storage in LLM Inference” introduces kvtc, a transform-coding pipeline that compresses transformer key-value (KV) caches primarily for storage and transfer in LLM serving, rather than for accelerating the per-token attention kernel during active decoding. The method combines 3 stages: (1) feature decorrelation via a PCA basis computed from a calibration dataset and reused across requests; (2) adaptive, variable-precision quantization with bit allocation solved via dynamic programming (DP), including groupwise scaling/shift overhead; and (3) lossless entropy coding (DEFLATE via nvCOMP in the reference implementation) to exploit residual redundancy after quantization. The central empirical claim is that KV tensors contain large, exploitable redundancy across heads and layers, enabling approximately 20× compression versus a 16-bit baseline with negligible degradation across a broad set of accuracy and long-context benchmarks, with materially higher compression (≥40×) available at modest quality cost in some regimes. The system claim is that such compression materially improves the economics of multi-turn, prefix-reuse serving by extending effective KV cache capacity in GPU HBM and host tiers (DRAM/NVMe) and by reducing inter-node and GPU↔host bandwidth demands, thereby improving cache hit rates and reducing time-to-first-token (TTFT) relative to recomputation when caches would otherwise be evicted. KV CACHE AS THE DOMINANT STATE VARIABLE IN INFERENCE ECONOMICS KV cache growth is linear in context length and is multiplicative in layers and attention heads, making it an increasingly dominant constraint as (a) context lengths expand, (b) models add layers and maintain large hidden dimensions, and (c) production workloads shift toward iterative and tool-augmented interactions that repeatedly reuse long prefixes. The paper uses the canonical 16-bit KV cache size formula (4·l·h·d_head·t) bytes and reports 16-bit KV cache sizes per 1K tokens of context that are already operationally large: 128MiB for Llama 3.1 8B, 160MiB for Mistral NeMo 12B, and 320MiB for Llama 3.3 70B Instruct. In binary units, these figures imply per-token KV footprints of 128KiB/token (Llama 3.1 8B), 160KiB/token (Mistral NeMo 12B), and 320KiB/token (Llama 3.3 70B Instruct) at 16-bit. For a 10K-token prompt (10×1K in the paper’s binary convention), the 16-bit KV cache sizes scale to approximately 1.25GiB (Llama 3.1 8B), 1.56GiB (Mistral NeMo 12B), and 3.13GiB (Llama 3.3 70B Instruct). These magnitudes explain why stale caches create a throughput–latency dilemma: retaining them in HBM maximizes responsiveness on future turns but crowds out concurrent sessions; evicting them forces quadratic-cost prefill recomputation and increases TTFT; offloading them to host or storage introduces large transfer overhead and consumes DRAM/NVMe capacity. A key operational nuance emphasized is that modern serving stacks increasingly treat KV caches as a database, leveraging block paging and shared-prefix reuse. In the common disaggregated serving design (separate prefill and decode nodes), KV cache transfer becomes a dominant category of cross-node traffic. Under that design, any reduction in KV cache size directly increases effective fabric capacity and reduces tail latency attributable to congestion, while also enabling longer cache lifetimes in “hot” (HBM) and “warm” (CPU DRAM) tiers that raise cache hit rates and reduce recomputation frequency. The paper’s quantitative example illustrates the economic stakes: a 1,000-line code file tokenized at ~10 tokens/line yields ~10K tokens; for Llama 3.3 70B, an 8-bit KV cache for that context is ~1.6GiB. Reuse across subsequent turns or parallel chats around the same file is valuable, but HBM scarcity makes retaining many such caches infeasible without compression. TECHNICAL MECHANISM: WHY KV CACHES ARE COMPRESSIBLE AND HOW KVTC EXPLOITS IT The technical rationale begins with an empirical observation: keys (and, to a lesser extent, values) across different attention heads can be aligned into a shared latent space using orthogonal transformations (Procrustes alignment). This supports the hypothesis that head-specific projections introduce rotations of a common subspace rather than completely distinct information, implying that concatenating across heads and layers should reveal low-rank structure suitable for linear decorrelation and dimensionality reduction. The method operationalizes this using a PCA/SVD basis learned from calibration data rather than recomputing a decomposition per prompt. This design choice targets production viability: per-prompt SVD is computationally expensive and scales poorly with long prompts and frequent cache updates. kvtc is explicitly structured as an offline-calibrated, online-applied codec: Calibration (performed 1 time per model and compression setting for DP allocation) A calibration dataset is forwarded through the model to collect KV caches. Token positions are pooled, and a subset of positions is sampled. Keys and values are processed separately. Several implementation choices are highlighted as decisive for stability: Rotary positional embeddings are effectively removed prior to compression (“undo positional rotations”), because positional rotations degrade the apparent low-rank structure of keys. “Attention sink” tokens (the earliest tokens in the sequence) and a sliding window of most recent tokens are excluded from compression because they disproportionately affect attention patterns and are empirically more sensitive to reconstruction error. Cross-layer concatenation is used: keys (or values) from multiple layers and heads at the same token position are concatenated along the feature axis to form a higher-dimensional feature vector. PCA is computed over these concatenated vectors, improving robustness relative to per-layer or per-head PCA. The PCA basis is computed via SVD of centered calibration data, using randomized SVD for scalability with a target rank cutoff. The paper reports calibration regimes of 160K tokens for several models with a 10K PCA dimension cutoff (8K for Qwen variants with fewer KV heads), selected to fit within a single 80GB H100 memory envelope and complete within minutes. A critical economic detail is that the same PCA basis can be reused across multiple compression ratios; only the DP-derived precision assignment changes per compression target. Compression (applied between inference phases) Compression operates on stored KV cache tensors, not on weights, and does not modify attention computation. The KV cache is projected into the PCA basis, quantized, packed, and then entropy-coded. Compression is positioned as a background or between-phase operation (after decoding, or between prefill and decode), executed on GPU or CPU depending on where the cache currently resides. The design intent is that compression should not sit on the critical per-token decoding path; it is a storage and transport optimization. Decompression (performed prior to reuse) Decompression reverses the entropy coding and quantization and applies the inverse PCA projection. A practical latency optimization is proposed: inverse projection can be performed layer-by-layer using submatrices of the PCA basis, allowing generation to begin before the full cache is reconstructed, reducing TTFT. Quantization and bit allocation are the core differentiators versus simpler PCA truncation. PCA provides ordered components by variance; kvtc uses DP to allocate a global bit budget across PCA coordinates (and across groups of coordinates) to minimize reconstruction error in the decorrelated domain. Groups of subsequent PCA coordinates share 16-bit shift and scale factors (a microscaling-inspired design), and the DP algorithm jointly selects group size and precision type under a bit budget, including the overhead of per-group metadata. DP commonly assigns 0 bits to many trailing PCA components, which both increases compression and provides a mechanism to trim the PCA basis to the subset of components that actually carry payload, reducing compute and storage overhead of the projection matrices in deployment. Lossless entropy coding then exploits the structure induced by quantization. DEFLATE is used in the reference implementation, and the paper emphasizes that the incremental gain from the lossless stage is content-dependent but meaningful, with an average uplift of ~1.23× on top of quantization in the reported regime. An ablation in the appendices indicates that GPU-friendly variants (GDeflate) can achieve nearly identical compression ratios (≤0.1 difference in measured cases), implying that throughput-optimized lossless codecs can likely be substituted without sacrificing meaningful compression. EMPIRICAL RESULTS: ACCURACY, COMPRESSION, AND LATENCY General-purpose 8B–12B dense models The paper evaluates Llama 3.1 8B, MN-Minitron 8B, and Mistral NeMo 12B across math/knowledge (GSM8K, MMLU) and long-context tasks (Qasper, Lost in the Middle, RULER Variable Tracking) under a simulated multi-turn regime where compression/decompression is applied periodically, with a sliding window of recent tokens excluded. A consistent pattern appears: kvtc maintains near-vanilla performance through 16× compression settings, and remains competitive at 32×, with degradation becoming task- and model-dependent at 64×, particularly on long-context retrieval metrics when compression is pushed aggressively. Selected quantitative anchor points from the paper’s standard-error table (all values are reported with the paper’s evaluation setup and token-window exclusions): Llama 3.1 8B Vanilla: GSM8K 56.8, MMLU 60.5, Qasper 40.4, LITM 99.4, RULER-VT 99.8 kvtc16×: GSM8K 56.9, MMLU 60.1, Qasper 40.7, LITM 99.3, RULER-VT 99.1 kvtc32×: GSM8K 57.8, MMLU 60.6, Qasper 39.4, LITM 99.1, RULER-VT 98.9 kvtc64×: GSM8K 57.2, MMLU 60.7, Qasper 37.8, LITM 90.2, RULER-VT 95.9 These results indicate that, for this model, long-context sensitivity emerges at 64× with meaningful drops in LITM and RULER-VT, while math/knowledge scores remain stable, implying a differential sensitivity consistent with key-vector precision being more critical for retrieval-style behavior. Mistral NeMo 12B Vanilla: GSM8K 61.9, MMLU 64.5, Qasper 38.4, LITM 99.5, RULER-VT 99.8 kvtc16×: GSM8K 62.0, MMLU 64.4, Qasper 37.6, LITM 99.8, RULER-VT 99.5 kvtc32×: GSM8K 62.2, MMLU 63.8, Qasper 37.5, LITM 99.6, RULER-VT 98.7 kvtc64×: GSM8K 61.9, MMLU 61.4, Qasper 38.0, LITM 95.3, RULER-VT 98.0 Here, degradation at 64× is visible but materially smaller than the Llama 3.1 8B LITM drop, suggesting model-architecture or training-data differences can change the tolerance envelope for aggressive KV cache distortion. MN-Minitron 8B Vanilla: GSM8K 59.1, MMLU 64.3, Qasper 38.2, LITM 99.8, RULER-VT 99.4 kvtc16×: GSM8K 60.3, MMLU 64.1, Qasper 38.6, LITM 99.3, RULER-VT 98.8 kvtc32×: GSM8K 59.1, MMLU 63.7, Qasper 37.7, LITM 86.9, RULER-VT 96.0 kvtc64×: GSM8K 57.8, MMLU 62.1, Qasper 38.1, LITM 59.5, RULER-VT 93.4 This model shows markedly higher sensitivity on LITM at 32× and 64×, despite stable short-context metrics, reinforcing that “compression safety” is not monotonic in parameter count and that pruning/distillation choices can alter KV cache redundancy or robustness. Comparisons to baselines The paper compares kvtc to quantization baselines (KIVI, GEAR, FP8) and eviction baselines (H2O, TOVA), plus an SVD-based prefill-optimization method (xKV). Across the reported tasks: Low-bit quantization methods at modest compression (2-bit KV schemes) show earlier degradation in long-context behavior than kvtc at substantially higher compression settings. Eviction methods perform poorly as generic compressors for long-context tasks, consistent with their objective function (selective pruning) being misaligned with “lossless-ish storage for reuse.” xKV shows competitive results on some tasks but a consistent underperformance on Qasper relative to kvtc and vanilla in the provided tables, consistent with method-specific distortions introduced by its decomposition regime. Reasoning models and high-variance tasks For DeepSeek-R1-distilled Qwen 2.5 reasoning models, the paper evaluates AIME 2024/2025 and LiveCodeBench coding. Results are averaged over 8 runs with large variance, but a key inference is that kvtc at ~9×–21× compression achieves broadly similar AIME scores within variance bands, while coding performance remains stable at ~9× and degrades more visibly at ~18×–21× on the 7B model. An important nuance is that smaller reasoning models already have smaller KV footprints (reported ~29KiB/token for Qwen R1 1.5B versus 131KiB/token for Llama 3.1 8B), so the economic value of aggressive KV cache compression is proportionally higher for large models and long contexts than for small models with short contexts, unless the serving system’s bottleneck is dominated by cache transfer rather than HBM capacity. Multi-GPU inference and pipeline parallel For Llama 3.3 70B Instruct run pipeline-parallel across 4 GPUs (20 layers per GPU), the paper compresses KV cache chunks independently per GPU. On MATH-500, the reported accuracy declines from 75.6 (vanilla) to 74.4 at 10× and 72.6 at 20×, with standard errors near ~1.9. NIAH and LITM remain at 100.0 for all tested ratios in that table. The paper notes that joint compression across chunks could improve accuracy for some offload scenarios but is not required for feasibility, highlighting an engineering trade-off between deployment simplicity in distributed settings and optimal global compression. Latency and TTFT economics A critical system result is the measured compression/decompression latency on an H100 for a non-fused implementation. For Mistral NeMo 12B in bfloat16: BS=8, CTX=8K: compression 379ms, decompression 267ms; vanilla recompute TTFT 3098ms; kvtc decompression TTFT 380ms BS=2, CTX=16K: compression 194ms, decompression 143ms; vanilla recompute TTFT 1780ms; kvtc decompression TTFT 208ms These measurements imply that, when a cache would otherwise be recomputed, decompressing a stored compressed cache can reduce TTFT by ~8×–9× in these scenarios, even without kernel fusion. The decomposition of runtime shows PCA projection and entropy coding as the largest contributors, implying that GPU-optimized kernels and faster GPU-native lossless codecs could reduce overhead further. The fundamental economic conclusion is that, in multi-turn settings with long prefixes, compression-induced overhead is likely dominated by the avoided prefill compute and avoided transfer overhead for uncompressed caches. KEY DEPLOYMENT-SENSITIVE DESIGN CHOICES AND FAILURE MODES Several design choices appear to be “hard requirements” rather than optional optimizations: Sink tokens and sliding window exclusions The paper’s ablations show that compressing early “sink” tokens can catastrophically degrade accuracy at high compression ratios (example: Llama 3.1 8B at 64× collapses on multiple tasks when sink tokens are compressed). Similarly, compressing the most recent tokens hurts performance, motivating a sliding window (default 128 tokens) that remains uncompressed. This introduces a predictable engineering constraint: kvtc is not a uniform compression of the full cache; it is a policy-driven, token-position-dependent codec. Production integration therefore requires correct handling of token positions, attention sinks, and window management, and these policies must be aligned with attention-kernel behavior and model-specific sink dynamics. RoPE handling Removing positional rotations prior to compression is described as important for preserving low-rank structure. In deployment, this implies that the codec must be position-aware and must invert and reapply RoPE correctly. This is an additional source of complexity relative to pure per-token quantization and is sensitive to model variants and RoPE parameterizations. Calibration set representativeness The method’s quality hinges on the PCA basis generalizing from calibration data to production data. The paper demonstrates relative stability with 160K–200K calibration tokens and explores domain shifts (general web text vs math traces vs code). Results suggest that moderate domain mismatch is tolerated at 16×–64×, while extreme compression (e.g., 256× in ablations) becomes materially more sensitive to calibration choice. In production, this implies that operators targeting the “negligible degradation” regime should be able to calibrate with broadly representative corpora, while operators targeting ultra-high compression for specialized workloads should expect tighter coupling between calibration domain and achieved quality. PCA matrix storage overhead and operational footprint A non-trivial hidden cost is the need to store PCA projection matrices per model. The paper reports that, prior to DP trimming, PCA matrices stored at 16-bit can amount to a meaningful fraction of model parameter count (examples reported: ~2.4% for Llama 3.3 70B, ~8.7% for Llama 3.1 8B). This overhead is amortized across all cached sessions for a model but competes with HBM/DRAM budgets in multi-model serving. DP-driven trimming can reduce this overhead at higher compression ratios by removing zero-bit components, but the directionality is not guaranteed at low compression ratios if many components remain active. In distributed inference (pipeline parallel), per-chunk PCA can reduce matrix sizes, but may reduce cross-layer decorrelation benefits if fewer layers are concatenated. SYSTEM-LEVEL IMPLICATIONS FOR GENERATIVE AI INFRASTRUCTURE GPU AND HBM The principal infrastructure implication is that KV cache compression at storage time targets the dominant memory allocator stressor in stateful serving: the accumulation of idle or warm conversation state. For workloads with long reusable prefixes (code assistants, enterprise agents with large system prompts, repeated RAG scaffolds, document chat), the limiting resource frequently becomes HBM reserved for KV caches rather than compute. By compressing stale caches by ~20× (or more), the same HBM budget can retain a materially larger working set of cached prefixes, increasing cache hit rates and reducing recomputation. This effect is multiplicative with cache-aware routing and prefix sharing: more prefixes can remain resident (hot or warm) and can be routed to nodes that already hold them, improving both throughput and tail latency. However, kvtc as described does not reduce the active KV cache footprint during the actual attention computation for a currently decoding sequence, because the model operates on decompressed KV caches during decoding. Therefore, the method does not directly reduce HBM bandwidth consumed by attention kernels during steady-state decode, and does not directly address the “memory traffic per generated token” bottleneck that motivates online KV quantization and eviction strategies. The primary HBM benefit is increased effective capacity for caches between turns and reduced HBM pressure from storing many idle sessions, not reduced per-token decode bandwidth. Compression and decompression themselves consume GPU compute and memory bandwidth. The measured decompression TTFT of ~208ms–380ms in the provided benchmarks indicates that the overhead is real but can be materially smaller than recomputation of long prefixes. In an HBM-constrained serving environment, this overhead can be interpreted as a trade between (a) maintaining more caches warm and paying decompression on reuse versus (b) evicting caches and paying full prefill recomputation. The decision boundary will depend on distribution of inter-turn idle times, probability of reuse, and SLA sensitivity to TTFT. kvtc expands the feasible region where keeping caches is economically rational, especially for long prompts. CPU AND DRAM The method implies a stronger role for CPU DRAM as a warm KV cache tier. A ~20× compression ratio changes the practical scale of “warm state” that can be stored per server. Using the paper’s reported KV cache sizes, a 10K-token 16-bit KV cache for Llama 3.3 70B is ~3.13GiB; compressing by ~20× would reduce this to ~160MiB. At that size, storing hundreds to thousands of warm conversation states in DRAM becomes materially more feasible, increasing cache hit rates and reducing NVMe dependence. This can shift system design from “HBM-only hot caches with aggressive eviction” toward “HBM hot + DRAM warm with long retention,” which is structurally analogous to CPU page cache hierarchies in classical systems design. CPU compute implications depend on where compression is executed. The paper explicitly allows compression on CPU if the cache is already in storage, but the strongest bandwidth savings are achieved when compression happens before moving KV caches off the GPU. If an operator chooses GPU-side compression prior to PCIe/NVLink transfer, CPU compute overhead is modest (orchestrating and DP calibration offline). If an operator instead transfers uncompressed caches to CPU for compression, bandwidth savings are forfeited and CPU memory bandwidth becomes a bottleneck. Therefore, the most economically coherent deployment path is GPU-native compression/decompression with CPU DRAM used as the warm storage reservoir.

TheValueist

16,549 次观看 • 7 个月前

Peter Thiel gave a speech in a Hilton in 2010 that holds the keys to unlocking the source of many of America’s most severe problems. Key quote: “The task in this world… where politics has become so broken… is to find a way to escape from it. It’s not a way to fix it.” Palantir is currently tightening its grip around all of our data. Elon Musk is diverting untold billions into a Mars fantasy. All of the anarchist, antidemocratic ideas of the PayPal Mafia and the “Dark Enlightenment”—to use technology as an “escape”—were already well in process 15 years ago. —The internet as “alternate virtual reality” so you don’t have to “constantly convince people.” This is why he funded Satoshi (Bitcoin), MAGA3X (Pizzagate, Q), and pushed Musk to buy Twitter —PayPal (now blockchain/crypto/BTC) was to “overturn the monetary system” —“Escape” now more often referred to as “exit” —“Autonomous countries” now known as the “network state” JD Vance is a full member of the cult of the broligarchs. Unfortunately, this has been a very thorough coup and they have backup. It’s worth really absorbing what the living Antichrist, Peter Thiel, is saying here: “I don't think despair is the only answer. And I don't think, and it's because I don't think politics is the only way to go. And my thinking on this, you know, started to take a turn towards a more optimistic perspective in the mid to late '90s when I got involved in the tech boom in Silicon Valley. I ended up being the co-founder of a company called PayPal where -- and the initial founding vision was that we were going to use technology to change the whole world and basically overturn on the monetary system of the world. And, you know, we can debate on how much it succeeded or how little it succeeded. And there were parts of it that I think have worked, and parts of it were, you know, the jury is still out. But the basic idea was that we could never win an election on getting certain things. Because we were in such a small minority. But maybe you could actually unilaterally change the world without having to constantly convince people and beg people and plead with people who are never going to agree with you through a technological means. And this is where I think technology is this incredible alternative to politics. And, you know, there are a number of different technologies we can outline, but the task in this world where politics has become so broken and so dysfunctional is to find a way to escape from it. It's not a way to fix it. It is a way to escape. And there are, you know, a number of different options. I think the promising one of the 1990s and this last decade has been to escape onto the Internet and to sort of create an alternate virtual reality. Questions, of course, is still how does it intersect with the real world? There are, I think, escaping to outer space is a promise, although I think the space technology is not quite there. So I think that's sort of for the second half of the 21st century. I think we can try to, you know, create autonomous countries on oceans, underwater, all sorts of other spaces. But I think technology is the vehicle for how we should be looking to escape and move beyond politics as we find it today.”

Jim Stewartson, Decelerationist 🇨🇦🇺🇦🇺🇸

156,800 次观看 • 1 年前