与「Trigger」相关的搜索结果

America is getting safer & we have record lows in violent crime under my father and @FBIDirectorKash , even Bill Maher is admitting it!! Breaking it all down on my triggered podcast coming up 6 pm et @rumblevideo

I set a camera really close to the launch pad to get this shot. It was a sound activated trigger since it wasn’t safe for me to stand here. That’s all 33 Raptor engines performing nominally as Starship heads to orbit for the first time.

Higgsfield is the most untold story in tech. $1BN in ARR in 18 months. Faster than everyone other than OpenAI and Anthropic. They spend $4M a month on models. They expect this to be $100K per person per month. They have 150 people working in a content machine. They will breed more millionaires than any other company in Kazakh history. For the first time, @alexmashrabov on the journey to $1BN in ARR. (below) 1. The Power of the Immigrant Founder Coming from Uzbekistan, Alex was pushed into competitive programming at age eight as his single path to reach the United States. For international founders, placing top in global competitions serves as the ultimate social elevator, instilling the relentless work ethic required to build breakout companies. 2. My Biggest Lessons in the Journey to Finding Product-Market Fit @higgsfield burned over $10 million of its $16 million seed round chasing hype and narrative rather than product quality. With under $5 million left, the team pivoted to product-led growth, solving camera control for creative directors, which immediately triggered organic hypergrowth without paid ads. 3. The 150-Person Content Team Powering Higgsfield's Billion in ARR Nearly half of Higgsfield's workforce consists of 150 in-house creative professionals producing tutorials, ads, and cinematic projects. Generating 90 minutes of TV-quality AI video requires 100 hours of raw output, proving human taste and curation remain the primary drivers of distribution. 4. We Spend $4 Million per Month on Models Higgsfield spends $4 million monthly on internal model usage, averaging $10,000 per employee so teams can freely vibe code and test workflows. Uncapped inference compute acts as a force multiplier, allowing top talent to discover breakthroughs at maximum velocity. 5. Why Chasing Benchmarks Is Bullshit and the Corporate Misalignment Occurring Public benchmarks have devolved into corporate psyops where lab researchers overfit test data to secure bonuses before job-hopping. Text-to-video benchmarks ignore real production workflows requiring 3,000-word prompts, proving direct customer iteration beats artificial leaderboards. 6. Why Team Sizes Won't Be Impacted as Much as People Think While AI handles over 60% of basic support requests, complex B2B environments cannot eliminate human teams. High product velocity constantly shifts rules and context, requiring smart, coordinated operators across legal and customer success. 7. Americans Are Way More Promiscuous When It Comes to Leaving Companies Silicon Valley workers routinely jump jobs every two years, prioritizing short-term trends over deep commitment. This transactional market gives international hubs an advantage, where cultural loyalty and team stability build compounding technical moats. (links in comments)

🟥 What you’re watching is total chaos on the White House lawn. Chinese state media stepped right in taking over front-row spots reserved specifically for the American press pool, triggering a wild shouting match with Secret Service and US reporters. The real kicker? The same legacy outlets that claimed they’d refuse to give Trump coverage suddenly want a piece of the Trump! 🍿🎥

here's a prompt to improve your agent harness based on what we've learned at cursor. enjoy # Improve this agent harness's token efficiency You're working on an LLM agent harness: the system prompt, tool definitions, request assembly, context caching, compaction, and retrieval, and how work is split across agents. Make the agent's runs cheaper without making it worse at its job. - Objective: lower price-weighted token cost per completed task. - Constraint: no measurable drop in task quality. Measure per task, not per request. Every turn resends the prefix (tools, instructions, setup, and the conversation so far), so a change that shrinks each request but adds turns can cost more. Weight tokens by billing type: output, uncached input, and cached input are priced very differently. Work in this order: map the harness and measure the baseline, rank the opportunities, make the changes that are safe to make directly, put the rest behind flags or in proposals, then report. Figures below come from one team's production coding agent and its multi-agent experiments. Use them to gauge magnitude, not as targets. One round of these changes (prompt trimming, tool offloading, cache layout, sparse line numbers, subagent tuning) cut that team's overall token cost about 7% with no loss in quality. The larger percentages apply only to the part of the request each change touched. ## Principles 1. Change what the harness sends, not how hard the model tries. Don't ask the model to conserve tokens. A harness that told its model to "take care to preserve tokens and not be wasteful" found it grew reluctant to take on ambitious tasks and sometimes quit, saying it wasn't supposed to waste tokens. 2. Capable models need definitions, not commands. Lists of "DO NOT", "You must", and "Important", and guards against older models' habits, can usually be replaced with plain descriptions of what each tool does. One team cut about two-thirds of its system prompt this way, and the shorter prompt worked across model families. Instruct only on what the model can't know (the product, the environment, the user's processes) and on quirks you've seen in transcripts. 3. Static context is for what most turns need. Everything else should be discoverable when needed. Less up-front context also means less confusing or contradictory information. 4. Expect removals to win. Guardrails written for weaker models, coordination steps that became bottlenecks, and prompting for behavior the model now does on its own all cost tokens. 5. Real usage decides. Evals are a fast proxy, but they skew toward hard problems and miss the real mix of requests. ## 1. Map the harness and measure the baseline Find: - Where requests are assembled, the system prompt, and tool schemas. If a framework or SDK builds requests, find its hooks for message order, cache control, and tool loading. - How tool results are formatted, and how history is kept, trimmed, or summarized. - How subagents or parallel agents are spawned, if any. - Which models and provider APIs are used. From the provider's docs, get the prompt caching behavior (automatic or explicit breakpoints, TTL, minimum cacheable length) and the prices for output, uncached input, and cached input. - Existing logging, token accounting, and evals. If the harness doesn't record per-request token usage by billing type and cache hits, add that first. Everything later depends on it. Then render a few real requests (from logs, or by running representative tasks) and count tokens per section with the model's tokenizer or the API's usage fields. Produce: - Cost share by source × billing type. Sources: system prompt, tool definitions, skill/rule/integration descriptions, user messages, file reads, search results, command and other tool output, history, summaries, subagents. - Static tokens per request, cache hit rate, and turns per task. - Per tool: the share of runs that call it at least once, and its error rate. Read the rendered requests, not just the templates. Duplication, leaked volatile values, and misordered blocks only show up there. Rank opportunities by share of spend × fraction removable ÷ quality risk. ## 2. System prompt and injected context Label every instruction: - Keep: product or environment knowledge the model can't infer, fixes for quirks seen in this model's transcripts, and rules a mode depends on. - Rewrite: commands and emphasis into plain descriptions. Reminders into constraints: "No TODOs, no partial implementations" works better than "remember to finish implementations." Vague quantities into ranges: "generate 20–100 tasks" gets far more ambitious behavior than "generate many tasks." - Delete: things capable models do by default, guards against behavior you haven't seen from this model, text that repeats tool descriptions, and lines that could contradict a user request. Models trained to rank system instructions above user messages will side with the system prompt. - Move: anything per-user or per-request (date, environment, repo state, lists of skills or subagents, user rules) into a user-role setup message after the cache boundary. Audit other injected context the same way. As models improved, the team behind these figures dropped directory trees, pre-retrieved snippets, compressed copies of attached files, lint errors injected after every edit, forced expansion of short file reads, and caps on tool calls per turn. They kept small, high-value facts: OS, repo status, and open or recently viewed files. Skip checklists for open-ended work. The model optimizes the listed items and deprioritizes everything else. ## 3. Tool definitions Tool schemas ride along on every request. Most tools beyond the core set were each needed in under 20% of conversations, and moving them out of static context cut tool-description tokens 60%. Doing the same for integration tools (such as MCP servers), with names in context and full schemas in one folder per server that the agent can search with grep or jq, cut total tokens 46.9% in sessions that used them. - Keep in static context: high-frequency tools (for a coding agent: read, search, edit, shell), tools the model tries to call even when they're absent, and tools a mode depends on. - Offload the rest: leave a name or one-line pointer and make the full schema discoverable on demand. Group related tools so they load together, and put status (such as "needs re-authentication") where the agent will see it. - Tighten what remains: describe behavior and arguments, and drop usage lectures. - Pick the split by testing a few configurations and tracking tokens, cost, latency, tool-call errors, and task success. ## 4. Cache layout Order each request so the reusable prefix is as long as possible: `tool definitions → system instructions → [breakpoint] → setup message (skills, subagents, rules, environment) → [breakpoint] → conversation` - Keep the prefix byte-identical across turns. Use deterministic tool order and serialization, put timestamps and IDs after the boundary, and don't rewrite earlier messages except when compacting. - Use explicit breakpoints if the provider supports them. Otherwise rely on automatic prefix caching with the stable part first. Respect TTL and minimum-length rules. - Switching models mid-conversation throws away the cache (caches are per model and provider) and hands the new model a history it didn't write. When a different model is needed, run it as a subagent with fresh context. Explicit breakpoints plus moving per-request setup after them cut cold cache misses 20%. ## 5. Tool results and other context added during a run - Large outputs (commands, integrations, logs): write them to a file and return the path, size, and a short tail. The agent can tail, grep, or read ranges for more. Truncating loses data, and inlining bloats every later request. Treat long-running terminal sessions the same way. - High-volume formats: look for overhead repeated on every line or item. Numbering every 10th line of a file read instead of every line cut cache-read tokens 1.6% without hurting citation accuracy. Each number costs 3–5 tokens, and agents read tens of thousands of lines per session. Also check repeated absolute paths, verbose JSON keys, ANSI codes, progress bars, and repeated headers. - Good retrieval saves exploration turns. Adding semantic search alongside grep raised codebase question-answering accuracy 12.5% on average and cut the iterations users needed. - Tool errors waste tokens and leave confusing debris in context. Classify expected errors (invalid arguments, unexpected environment, provider error, timeout, user abort), treat unknown errors as harness bugs, and track rates per tool and per model. One focused effort along these lines cut unexpected tool errors 10×. ## 6. Long runs: compaction, subagents, and model mix - Compaction: keep the summarization prompt short and the summary compact, carry forward plan state and remaining tasks, and save the full history to a file the agent can search for details the summary dropped. A model trained to self-summarize from a one-line prompt wrote ~1k-token summaries with half the compaction error of a multi-thousand-token prompt that produced 5k+ token summaries. Untrained models may need more guidance, so test how short you can go. A more expensive summarization model made a negligible difference. - Scratchpads and running notes: rewrite them instead of appending. For repeated work in one environment, a small agent-maintained notes file with a line budget, loaded at start, is a promising way to shorten later runs. - Subagents: fresh context keeps the parent lean, but isolation adds coordination cost (duplicate or stale work). If the model already delegates on its own, remove prompting that pushes it to. Have subagents return short handoffs: what was done, findings, concerns, and deviations. A subagent should use a different model only when the user or harness says so. - Model mix: in large multi-agent runs, workers used at least 69% of tokens, and over 90% in most runs. A frontier planner with cheap workers matched a frontier model doing everything at about one-eighth the cost. Planner choice still changes worker spend. One planner that cost less on its own saw its workers use several times more tokens, and the run cost more overall. Measure the whole tree. - Routing and reasoning effort: send simple turns to a cheaper model or lower effort, and upgrade only when a stronger model is clearly better. A router built this way matched or beat single frontier models on user satisfaction at 41–68% lower cost. - Reasoning continuity: if the API returns reasoning items (including encrypted ones), pass them back on later turns and alert when they go missing. Dropping them cost one reasoning model 30% on a coding benchmark, and it burned tokens reconstructing its plan. ## 7. Fit the harness to each model Adapt to what each model was trained on instead of forcing one shape on all of them. If you've tuned the harness for a similar model, start from that version. - Edit format: use the one the model was trained on (for example, patch-style or search-and-replace). An unfamiliar format costs extra reasoning tokens and causes more mistakes. - Shell or tools: shell-first models fall back to `cat` or inline scripts. Name tools after their shell equivalents (such as `rg`), and if needed add: "If a tool exists for an action, prefer to use the tool instead of shell commands (e.g. read_file over `cat`)." - Literalness: some model families follow instructions literally and others tolerate imprecision. Some spiral on emphasized wording. Strip caps and emphasis for literal models. - Triggers: some models ignore a tool until told when to use it. A literal trigger works: "After substantive edits, use the to check recently edited files for linter errors. If you've introduced any, fix them if you can easily figure out how." - Progress updates: if a model reports progress through reasoning summaries, keep them to 1–2 sentences that note new findings or a change of tactic, and remove instructions about messaging mid-turn. - Quirks worth a targeted line: hedging or refusing as context fills ("context anxiety"), declaring completion early, stopping to ask permission, and calling tools that don't exist. Tie each added instruction to the transcript behavior it fixes. Re-audit when models change, since guidance one version needed can be dead weight for the next. ## 8. Validate - Offline: run a fixed set of realistic tasks before and after, ideally drawn from real usage and phrased the way users actually write (short and ambiguous). Compare task success, tokens, cost per task, turns, and tool errors. Don't ship a change that lowers success. - Online, if you have users: A/B test each change or small bundle. The primary metric is cost per completed task. Guardrails are task success signals, tool-call errors, latency, turns per task, and cache hit rate. For a coding agent, a good success signal is how much agent-written code survives over time. In general, check whether the user's next message moves on or reports a problem. - Ship only when cost drops and no guardrail regresses beyond noise. Record null results. ## What to change directly and what to propose - Change directly, each in its own revertible commit: token and cache telemetry, deterministic serialization and tool order, moving volatile content out of the cached prefix, explicit cache breakpoints, writing large outputs to files instead of truncating, passing back reasoning items that are being dropped, and fixes for recurring tool errors. - Change behind a flag so it can be tested: system prompt edits, tool offloading, output format changes, compaction changes, and subagent prompting. - Propose only: changes to which models run, routing, reasoning-effort defaults, or how work is split across agents. ## Traps - Asking the model to use fewer tokens or do less. - Truncating tool output. - Dropping reasoning items to save input tokens. - Volatile content in the cached prefix, or tool order that changes between requests. - Offloading a tool the model needs on the first turn or tries to call when it's missing. - Emphasis-heavy prompts (MUST, NEVER, IMPORTANT, all caps), especially with literal models. - Forcing a terser output format than the model was trained on. Fewer output tokens can mean less thinking and worse results. - Optimizing raw token counts instead of cost, per request instead of per task, or evals instead of real usage. - Switching models mid-conversation to save money. - Adding coordination layers that become bottlenecks. ## Report back with 1. The harness map and baseline: cost by source × billing type, with the biggest sources called out. 2. A ranked list of changes: layer, what changes, estimated savings and how you estimated them, quality risk, how to validate, and how to roll back. 3. The changes you made, including a system prompt diff with a keep, rewrite, delete, or move reason for each line. 4. A test plan for the flagged changes. 5. Gaps: anything you couldn't find or measure.

🚨SlowMist TI Alert🚨 💸 @BeatXswap Loss: 2,984,557 BTX (~$77,512) 🔍 Root Cause: The `LiquidityVestingConvert` contract calculates BTX quotes via `_calculateQuote()`, which reads `IUniswapV3Pool.slot0()` spot price as the sole oracle. No TWAP protection, no sanity check, no deviation limit. An attacker borrowed 6,000,000 BTX via flash loan, dumped it into the V3 pool to crash `sqrtPriceX96`, then called `deposit()` twice (10,000 + 2,000 USDT), triggering `POSITION_MANAGER.mint()` at the manipulated spot price and draining BTX from LP positions. 📌 Attacker: 0x67B2f08683A735cfE6f6E57fA86909b62218C2a1 📌 Victim: 0x1e647FAADb05f2124BFCcFC003EDc06D1A90bf5D 0x9a7A92240FBAc4030b65A6E61239928d6Bcc716F 📌 Vulnerable Contract: 0x1e647FAADb05f2124BFCcFC003EDc06D1A90bf5D Powered by Tx:

Confidential Intents TVL just crossed $50 million. Now $20M away from the $70M snapshot trigger for the near@3.33 campaign. $100 confidential balance on near​.com and one confidential swap is all it takes to qualify for Drop 1. The privacy renaissance runs on NEAR.

ZERO ALPHA Research Note 1/6 NVDA：第二个春天——从P带E到E带P 系列 1/6 NVIDIA这次财报，是我们重新研究NVDA的trigger event。最新季度营收达到 $96.2B，同比增长106%，Data Center收入达到 $89.0B，同比增长117%。一家已经跻身全球最大公司之列的企业，主营业务竟然重新实现年度翻倍，这使我们重新回头检查2023年以来NVDA的P、E和PE究竟发生了什么。这里的P代表股价，E采用GAAP diluted EPS，PE采用TTM GAAP P/E。真正有意义的并不是某一个时点PE到底高不高，而是P、E和PE三者在不同阶段分别怎样运动。 如果按照calendar quarter观察，NVDA从2023年以来大致可以分成三个阶段：第一春为2023 Q2–2024 Q2，中场为2024 Q3–2025 Q2，第二春为2025 Q3–2026 Q2。 这三个阶段虽然都属于同一轮AI产业扩张，却呈现出完全不同的资本市场结构。 第一春：2023 Q2–2024 Q2——P先走，E随后追上 2023年生成式AI爆发以后，市场首先买入的不是已经兑现的盈利，而是一个可能极其巨大的未来。第一春最直观的是股价变化：$27.69 → $46.64 → $40.70 → $61.42 → $86.25 → $116.83。市场很早就开始把AI未来写进P，但更值得注意的是PE同期却从 147x → 113x → 54x → 52x → 51x → 55x。股价大幅上涨，PE却从147倍迅速回落到50倍附近，原因只有一个：E增长得比P更快。 这一阶段的GAAP EPS同比增长大致为 28% → 854% → 1,274% → 765% → 629% → 168%，而营收同比增长则走出 -13% → 101% → 206% → 265% → 262% → 122% 的轨迹。也就是说，第一春并不是PE一直扩张，而是P首先冲出去，随后E以更惊人的速度追上，把高估值迅速消化掉。第一春本质上是一个 Top-down growth cycle：市场先发现AI的未来，P先走，E随后兑现。因此可以简单概括为：第一春，P带E。 中场：2024 Q3–2025 Q2——市场开始相信“大数定律” 第一轮爆发以后，增长明显进入高基数消化期。季度营收同比增长从 122% → 94% → 78% → 69% → 56%，方向非常清楚。市场很自然地形成一种判断：NVDA已经太大了，过去200%以上的增长不可能长期持续，未来应该逐步回落到40%、30%，最终进入20%左右的成熟公司区间。 这一时期PE也从第一春末期的大约55倍，经历 55x → 52x → 41x → 35x → 51x 的变化。股价仍然波动很大，但市场的叙事已经从“hypergrowth”逐渐转向“优秀但正在成熟的mega-cap technology company”。如果故事在这里结束，NVDA会遵循一条很典型的大公司成长路径：规模越来越大，增速越来越低，估值逐步回落，最终进入成熟期。 但真正改变我们判断的，是接下来发生的事情。 第二春：2025 Q3–2026 Q2——E重新加速，P却没有同步透支 从2025年下半年开始，NVDA的增长曲线没有继续向下，而是重新向上。季度营收同比增长从 56% → 62% → 73% → 85% → 106%。这条数字串可能是整个Research Note最重要的证据，因为它说明NVDA没有按照市场熟悉的“大数定律”从56%继续下降到40%、30%、20%，反而在更大的收入基数上重新进入年度翻倍。 与此同时，股价却表现得相当克制，从 $177.63 → $202.23 → $190.90 → $199.34 → $209.66。从2025年中到2026年8月，公司基本面发生巨大变化，但P只从约$178升到约$210。于是PE出现了与第一春完全不同的方向：51x → 50x → 39x → 30.5x → ~26.5x。同期GAAP EPS同比增长则重新进入高速区间，大致为 61% → 67% → 98% → 214% → 128%。部分季度受到H20 charge和低基数影响，不能机械比较每一个EPS百分比，但趋势非常明确：E重新加速，而P没有同步提前透支，因此PE持续下降。 这就是第二春与第一春最根本的区别。第一春中，市场先用高PE购买未来，随后等待E兑现；第二春则越来越像公司已经用业绩证明自己，E先重新加速，P却没有同步扩张，于是PE被盈利不断压低。第一春是 Top-down：P带E；第二春则开始变成 Bottom-up：E带P。 为什么2026年的106%，比2023年的101%更值得研究？ 表面上看，2023年的101%和2026年的106%非常接近，但两者的商业意义完全不同。2023年第一春启动时，NVDA季度营收大约只有 $13.5B；今天已经达到 $96.2B。第一春的100%增长，是一家刚刚进入AI爆发期的公司完成的；第二春的100%增长，则是一家已经成为全球最大公司之一、季度收入接近$100B的企业完成的。 因此，今天真正值得研究的问题已经不是“NVDA为什么又增长100%”，而是：NVDA已经这么大了，为什么还能重新增长100%？ 这也是第二春比第一春更有研究价值的地方。相似的百分比背后，绝对收入增量已经完全不是一个数量级。 ZERO Insight 从calendar quarter看，NVDA过去三年的轨迹已经非常清楚：2023 Q2–2024 Q2是第一春，市场先相信AI未来，P走在E前面；2024 Q3–2025 Q2是中场，增长减速，市场开始相信大数定律；2025 Q3–2026 Q2则进入第二春，E重新加速，P没有同步透支，PE反而持续下降。 第一春是P带E，第二春转向E带P。 我们正在见证NVDA从一个成功的成长股变成罕见的巨型成长股 2026NVDA的E重新推动市场发现它。