与「canon」相关的搜索结果

🚨 Thrilled to share that our lab will be presenting the 🏆 Best Paper at the NExT-Game Workshop at #ICML2026# today! 🎤 When Agents Lie: Premeditation, Persistence, and Exploitation in Repeated Games 🏆 Best Paper @ NExT-Game Workshop 📍 Conference Room S307 📅 Fri, Jul 10 🕐 13:00–13:20 KST Authors: @JerickShi @TerryJCZhang @bschoelkopf @conitzer @ZhijingJin 🤖 We introduce a three-stage endogenous promise protocol for repeated multi-agent games that asks not only whether LLM agents honor their public commitments when they can privately deviate, but also how model-on-model composition influences premeditated deception and persistent exploitation. 📊 Across six canonical games spanning binary and numerical action spaces, our evaluation of frontier models (GPT-5.2, Llama-4-Maverick, Claude-Opus-4.6) reveals: 🔹 Over 90% of promise-breaking instances are premeditated in agents' private plans. 🔹 Mixed-model groups with mismatched communication frameworks create systemic, persistent payoff gaps of up to 5.00 points from Round 0. 📄 Paper: #MultiAgentSystems# #LLMs# #GameTheory# #AI# #ICML2026#

Found something pretty funny around $CASHBULL. Robinhood has an actual registered bull logo mark. Not “bullish vibes”, not some random fan art — a live registered mark owned by Robinhood Markets, Inc. Logo: And now there’s a token called $CASHBULL trading on Robinhood Chain. That’s the part I like. We’re clearly in a bull meta again after $ANSEM, Robinhood Chain is starting to get attention, and this thing has the cleanest possible accidental lore: Robinhood. Bull. Robinhood Chain. 80% held/locked by @vladtenev in the canon. as far as weird on-chain coincidences go, this one is almost too clean. CA: 0x3cd4b6d387e4d876f4fb9eb20c48ca08f3d531f7

Two weeks ago, Ethereum researchers met in Berlin to continue charting the protocol's long-term trajectory, following along discussions with client teams in Svalbard in April. The updated strawmap is at and I attached a picture of it to this post. My own high-level takeaways: * "Lean Ethereum" is not a single one-shot upgrade, it is a collection of improvements that will come online to the Ethereum network over the course of three or four years. But make no mistake, this IS the third major iteration of Ethereum in the same way that the Merge was the second. Almost every major piece of the protocol will be replaced: - Verification through recursive STARKs, rather than direct re-execution. Recursive STARKs become an enshrined first-class core component of the protocol - Replacing everything quantum-vulnerable with quantum-safe alternatives - Consensus: decoupled available chain and finality, one or two-round finality. Theoretically optimal security properties, simpler than today, and faster than today - Multidimensional gas - State: not just tree structure, but what *types* of state are available - Changes to client architecture ... At the same time, simplification, cleanup and future-proofing. And this will all be done in a way that minimizes disruption to existing application. We've done this before (the Merge), we can do it again. * H-star (aka Hegota) is probably Ethereum's last thematically "pre-Lean" fork. Starting from I-star, most of everything we do will have a very strong "Lean" feel to it in one way or another. * Privacy is no longer an afterthought, it is a first class goal. When designing Frames, the mempool, additions to the state tree, we explicitly ask the question "okay, how do quantum-safe, intermediary-free privacy protocol transactions go through this, and what is the overhead?" * Formal verification of everything for security. * FV also makes us much more comfortable with canonicalization (having pieces of the protocol that are directly defined as a piece of bytecode expressed in some language). evm-asm is being written in part to become a canonical proof system for the EVM. * Quantum safety has shifted up a LOT in priority. This adds a lot of work (eg. finalizing a quantum-safe blobs design has become urgent; this work has already been ongoing for months) * Probably the single most disruptive part of the plan is the changes to state. There is growing consensus around leaving present-day-style "dynamic state" mostly unchanged, but scaling it only a medium amount, and adding new types of state that are more scalability-friendly (eg. no need for builders to sync/store all of it) but more restrictive, and that will scale a large amount. eg. possible Ethereum in 2030: 2 TB of present-day-style (dynamic) state, and 100 TB of new-style (scalable but restrictive) state This "new-style" state would work very well for ERC20s, NFTs, many defi use cases, but not eg. highly "central" objects like Uniswap contracts, or onchain order books, or other complex things (which are crucial for Ethereum but which only take up a small percentage of state) Hence, it will not be *necessary* to rewrite any apps, but it will be *very cost-effective* to eg. rewrite an ERC20 token into a newer design that uses a new type of UTXO storage that is currently being explored, so that it will have >10x lower txfees. Design of these new state types (current ideas: keyed nonces, ring buffers, UTXOs, statically accessible state, temp state) is an area where we will need a lot of feedback from application developers (incl. privacy-friendly application developers) and probably several rounds of rethinking and iteration. * In the context of a much larger total state size, we need to figure out the incentive issues around who stores this state and what motivates them to. Even saying "each node stores 1%" is not good enough - why do they store that 1% and why are they willing to serve it? This is being elevated as a first-class research area. * Ethereum will need to have a "VM" other than EVM in one form or another - at the very least, we need something like leanISA for recursive STARKs - and the gains are large in exposing it to users so that we support programmable privacy and better scalability. Right now, the most likely contenders are leanISA and RISC-V. My own ideal is that in this world, we adjust the protocol so that the EVM becomes a high-level-language compiler-level feature, and the protocol only "sees" RISC-V / leanISA directly. But this is still far away. * Gas limit increases, blob increases and slot time decreases will happen many times over the next ~5 years. We expect a large gas limit increase with Glasterdam. Each step of increased scale or decreased slot time is a matter of getting to the point where it is safe to do it, which comes from a combination of client optimization and protocol changes. Ethereum is CROPS. Ethereum is scaling. Ethereum is reinventing itself. Onward.

Japan’s largest financial institutions including MUFG, Mizuho, SMBC, BlackRock Japan, State Street, and Japan Exchange Group are bringing $1.6T JGB repo market on-chain. Zenith, the canonical EVM & SVM execution layer of Canton Network, has joined the initiative. Read more.

Japan’s largest financial institutions including MUFG, Mizuho, SMBC, BlackRock Japan, State Street, and Japan Exchange Group are bringing $1.6T JGB repo market on-chain. Zenith, the canonical EVM & SVM execution layer of Canton Network, has joined the initiative. Read more.

.@Canonical 宣布 Livepatch 现已支持 Arm64，运行 Core 26 / 26.04 LTS on Arm64 的用户都可以注册。 该服务属于付费增值服务，不过个人用户每个账户可以获得 5 台使用权，用户只需要注册 #Ubuntu# Pro 即可，所以现在就去给你的甲骨文羊毛机配置 Livepatch 吧。 操作方法：

Been iterating on @tomosman's loop. This one's winning: /goal produce a verified, code-derived behavioral spec for this web platform, captured in one canonical spreadsheet that carries every feature from spec -> tested -> fixed -> verified. Why: we need a single source of truth that maps every feature to its expected behavior *as the code implements it*, so that gaps and bugs surface and the platform can be driven to a known-good state. The spreadsheet is the source of truth. Work on the current repo. Do Phase 0 and Phase 1 under this goal; when the spec is complete, switch into the /loop below to drive testing and remediation. Keep moving through phases without stopping, except at a real checkpoint (defined below). Phase 0 - Plan (first): Detect the stack, the feature surface (routes, pages, components, API endpoints, background jobs, auth, settings…), and the test infra that already exists (unit/integration/e2e, browser automation, seeds/fixtures, a runnable dev server). Propose (a) how you'll inventory features, (b) the spreadsheet schema, and (c) how you'll test in the loop given what's available. Proceed once the plan holds. Phase 1 - Catalog & spec: Read the code and, for every feature, write a user story + the expected behavior as implemented, citing the file/function. Where the code is ambiguous, or behavior is undefined, log an open question - don't guess. Record every feature as a row in the canonical spreadsheet (create with the xlsx skill). Exit: every discoverable feature has a row. One row, concretely: | Area | User story | Expected behavior (from code) | Status | Defects | Type | Notes / source | |---|---|---|---|---|---|---| | Auth | As a returning user I want to log in with email+password so I can reach my dashboard | `POST /api/login` validates via bcrypt, sets httpOnly session cookie, 302 -> `/dashboard`; bad creds -> 401 + inline error | Spec'd | - | - | `api/auth/login.ts`, `LoginForm.tsx` | Canonical artifact: exactly one .xlsx, updated in place across every phase and loop iteration - never fork into per-phase or per-iteration files. Status flows Spec'd -> Tested-Pass / Tested-Fail -> Fixed -> Verified. The main thread is the single writer. Agentic execution: - Delegate breadth to subagents: fan feature discovery and per-area testing across subagents so the main thread stays focused. - Verify by running, not claiming - report real command/test output; state skips and unknowns plainly. - Checkpoint (pause, ask, end the turn) only for a destructive/irreversible action, a fix needing a genuine product decision, or input only I can give. Otherwise, keep going. - Self-check at each phase/loop boundary via a fresh-context subagent: re-verify the spreadsheet against the code (Phase 1) and against actual results (each loop pass). /loop Quality cycle - once the spec is complete, iterate test -> fix -> re-test until clean. Each iteration, in order: 1. Test: exercise every user story not yet Verified against the running app, preferring the strongest method available (browser/e2e automation > existing suites > documented static check only where execution truly isn't possible). Record actual pass/fail in the same spreadsheet; log every defect with its type (functional/logistical or UX). No app-behavior changes in this step. 2. Fix: think hard about root cause, then fix every functional/logistical and UX defect logged this iteration - cause, not symptom. Scope: only logged defects; no new features, no unrelated refactors. Update each row's status. 3. Re-test: re-run every story touched by a fix using the same method; set Verified, or back to Tested-Fail with notes if the fix didn't hold. Exit when all user stories are Verified and no open functional/UX defects remain. Safety cap: if a story is still failing after 3 full iterations, stop, leave it Tested-Fail with root-cause notes, and report it rather than looping further.