与「Quan5」相关的搜索结果

🍵 Chè Quy Linh Cao – “Mai rùa” kết hợp với các vị thảo mộc: thổ phục linh, cam thảo, thục địa... Bạn đã ăn chưa? 🛵 Mình ăn chè Cao Quy Linh (Quy Linh Cao) ở tiệm Hà Ký Quận 5 không biết có đúng mai rùa thật hay không, nhưng ăn ngon hết sẩy là được rồi😂. Cái vị thanh mát, ngọt dịu, dai dai… ăn một tô là ghiền! Nhìn video ông bạn này làm thật công phu, hướng dẫn làm chi tiết, nhìn thèm chảy nước miếng luôn! Nhà ai còn mai rùa thì thử nhé! Bạn đã thử ăn chưa? Comment bên dưới kể mình nghe với! 👇 #CheQuyLinhCao# #QuyLinhCao# #AnVuiSaiGon# #Quan5# #CheSaiGon# #FoodSaiGon# #MaiRuaThatHayKhong#

如果我们可以重新理解 Quant Developer。 这并不只是思想实验。 Jane Street 2026 年公开的研究方向包括机器学习、编程语言、编译器、ASIC、FPGA、分布式 shared log、incremental computation、查询优化、分布式存储和形式化验证，而Citadel GQS 则把实时数据、HFT 执行和低延迟 ML 推理放进了同一个 Quantitative Research Engineer 岗位。 再次强调，市场是一个高维、受驱动、耗散的非平衡系统。 订单持续进入、撤销、成交，信息、资本和风险不断注入，异质的参与者相互作用，系统几乎从未达到平衡。 当看到Jane Street 把 graph-structured、incremental computation 列为长期研究方向，我想这是一个值得认真理解的信号。 如果我们发现研究对象持续变化时，计算本身或许也需要围绕变化来组织。 一条报价更新，并不意味着整个市场都需要被重新计算。 它首先改变某些局部状态，再沿着依赖关系，影响相关资产的估值、组合的风险暴露，以及尚未成交的订单。 如果把这些计算关系展开，我们会看到数据连接特征，特征连接预测，预测连接决策，决策通过成交与持仓，反馈到下一轮计算。 这里必须区分两件事。 计算图中的依赖关系，不自动等于市场中的因果关系。但只要我们能够明确哪些结果依赖哪些输入，就有机会在新事件到来时，只更新受到影响的部分。 这正是 incremental computation 最吸引我的地方，它让计算资源跟随变化分配。困难的问题也随之浮现。哪些状态已经过期，筛选必须更新的传播，可以合并的计算。我们开始寻找，在并发和异步执行中，如何避免把不同时间的市场状态拼成一个从未真实存在过的世界？ 于是，延迟就不再止于程序运行了多少微秒。判断抵达市场时，你应该着眼于支撑判断的那个市场是否仍然存在。 想想吧，一个离线表现出色的模型，如果依赖陈旧的数据、无法承受行情突发时的排队，或者不能及时更新风险状态，那么它在回测中发现的信息优势，可能在执行之前就已经消失。 因此，Quant Developer 的工作可以被理解为，他们需要在有限的时间、算力和通信预算内，维护一个足够及时、足够一致、能够用于行动的市场内部模型。 编译器、分布式系统、硬件加速和形式化验证，开始汇聚到同一个问题上。 编译器决定计算如何被表达和执行； 分布式系统决定不同节点如何组织事件与状态； 硬件决定数据移动和运算的成本；形式化方法则帮助我们检查，某些关键约束是否会在复杂的执行路径中被破坏。 这些工作共同决定一个数学上的预测，试图成为现实中的有效决策。 而非平衡系统的视角，提供了一组进一步追问的方向：外部事件，内部状态，反馈是抑制还是放大扰动，输入速度和处理能力的关系对于系统的影响。 当然，市场是耗散系统本身并不会自动产生 Alpha。我想，我们只有把这种直觉落实为可观测的变量、明确的机制和能够被数据推翻的预测，它才开始具有研究价值。 它确实改变了我们看待这个职业的方式。 Quant Developer 所构建的一直是一个嵌入市场之中的实时决策系统。 这个系统观察市场，也通过自己的行动改变市场：它必须在变化尚未结束时做出判断，在信息尚不完整时承担后果。

最近的一个妖币 ethereum:0x4a220e6096b25eadb88358cb44068a3248254675 暴涨 90%+ 破 290U，逻辑其实非常清晰： 不是散户拉盘，而是真正的传统金融（TradFi）巨头落地！ · 美国落地：Quant 被 The Clearing House 选为 On-Chain Money Initiative 的互操作/编排层（日均清算量超 2 万亿美元）。 · 英国落地：汇丰、巴克莱、渣打等 7 家银行已通过 Quant 完成真实 Tokenised Deposit 交易。 Quant 抢的不是公链流量，而是银行间资产上链的“中间件/互操作层”。随着 Fusion 节点和真实交易量提升，$QNT 作为原生质押资产的价值捕获才刚刚开始。 这就是基本面驱动的行情 📈

Another major arrangement that I expect Quant ($QNT) will announce an official partnership with in the coming months is Project Agora. Agora is multi-currency shared platform for wholesale cross-border payments by France, Japan, Korea, Mexico, Switzerland, the UK, and the US. Also involved are HSBC, Citi, JPMorgan, Santander, Deutsche Bank, the BIS, SWIFT, Visa, and Mastercard.

I asked people: "which robotics labs and startups have the highest talent density?" 28 votes: Physical Intelligence (@hausman_k, @svlevine, @chelseabfinn, @adnan_esm, @brian_ichter, @QuanVng, @lachygroom) 18 votes: Generalist (@peteflorence, @andyzengineer, Andrew Barry) 9 votes: Sunday (@tonyzzhao, @chichengcc) 6 votes: Skild AI (@deepakpathak, @gupta_abhinav_) 4 votes: Dyna (@Lindon_Gao, @YorkYang5050, @JasonMa2020) 3 votes: Bracket Bot (@sincethestudy) 3 votes: OpenAI Robotics (@model_mechanic, @PengchuanZ, @ChengshuEricLi) 2 votes: 1X (@BerntBornich) 2 votes: The Bot Company (@kvogt, @pariljain, @lukeholoubek) 2 votes: Figure (@adcock_brett) 2 votes: Genesis (@zhou_xian_, @theo_gervet, @johnsonwang0810) 2 votes: Prometheus (@JeffBezos, @vik_bajaj, @sherjilozair, @wgussml, Alex Graves) 2 votes: Robocurve (@chooi_jeq) 2 votes: Tesla (@elonmusk) 2 votes: Weave Robotics (@kaandogrusoz, @evan_wineland) People couldn't pick a company they work at or founded. Disclosure: I'm a small investor in Physical Intelligence. I didn't vote.

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.

HABEMUS TESTNET — DAISUGI v0.1 A post-quantum Ethereum testnet using hash-based SPHINCS signatures with non-native account abstraction. Big thanks to @riva_labs and @GiulioRebuffo. Coming next: • Frame Transactions • Signature aggregation via LeanSPHINCS Believe in somETHing. Link ⬇️

A note on recursive STARK mempools (EIP-8288) This is an EIP that I am hoping we can get included in I-star (the fork after Hegota) that you can think of as the next step after Frames, that would unlock extreme amounts of power. Particularly: * Ultra-cheap quantum-safe signatures (SPHINCS-). Much of the cost savings comes from the fact that the signature data (~3 kB) does not have to go onchain * Ultra-cheap quantum-safe privacy protocols. Status quo minimum cost for private txs is ~300k if you engineer very well (no one does), status quo quantum-safe is ~10M gas, this could reduce it to low tens of thousands. * Universal support for your favorite new signature or proof scheme without needing EVM changes. Whatever you use (Falcon, ML-DSA, some other lattice-based thing, something code-based or isogeny-based or even more esoteric), you can just wrap it client-side in a STARK, onchain gas cost low tens of thousands just like privacy protocols. Hopefully, Ethereum will never need "please support my favorite cryptographic algo" politics again. * Private account abstraction: keep your account logic private, and in a private location onchain. Then you can make one transaction to change the ownership of all your onchain state - accounts, defi positions, privacy protocol notes, everything - without revealing which objects' ownership you're changing. Here's how it works. Your transaction can include a type of frame that we call a "dependency frame". The frame is a list of statements, asserting claims like "message hash M was signed by SPHINCS- public key P" and "data hash D was proven to satisfy a statement defined by verification key V". When you send your transaction, you send it in an envelope, which includes a signature or a STARK for each statement in a dependency frame. Once the transaction reaches the mempool, nodes aggregate them. Each node runs a loop: wait one tick (eg. 500ms), aggregate all new envelopes (either single-tx or multi-tx) that you've seen, remove any transactions that are expired, generate a STARK recursively proving all dependencies, and send a new multi-tx envelope containing that STARK. Hence, the bandwidth load is bounded: each node's outbound is one STARK (~100-300 kB) per tick, plus each transaction getting broadcasted through the network once (as happens already). The block builder acts as "yet another mempool node", receiving envelopes from the mempool (plus any side channels), generates its own STARK covering the subset of transactions it intends to include in the block, and adds that STARK to the block. Total onchain overhead: one STARK (100-300 kB), plus 96 bytes for each statement being proven. This is what I've called before ( ) "The Proof Singularity". Today, we have all the ingredients to actually implement it. As a developer, this requires a somewhat different workflow than you are used to, but it is conceptually simple. Any signatures or STARKs, you put into a separate frame. Then the main logic that today is verifying a signature or STARK, you replace with checking for the existence of a frame that includes the correct statement as a dependency. Examples of useful statements: * [tx sighash] verifies against [the pubkey at sload(0)] * there exists a secret and a merkle branch such that hashing secret+0 and applying the merkle branch outputs (public) root R, and hashing secret+1 outputs (public) nullifier N * there exists a secret address A, salt S and signature Z such that sload(0) = hash(A, S) and a merkle proof of address A inside a recent ethereum state contains some pubkey D where [tx sighash] was signed by D [this is private account abstraction; all variables except [tx sighash] and sload(0) are private; you can also make D a STARK verification key] * there exists an ML-DSA signature signing [tx sighash], that verifies against an ML-DSA pubkey whose hash is sload(0) At the core, this is moving any compute and data other than bookkeeping "business logic" outside the core path of Ethereum execution, sharding and parallelizing it via the mempool. Notice also that this requires agreeing on a _language_ (aka. an ISA) for the recursive STARKs to define statements in. The current leading candidate is RISC-V. So this would also de-facto be Ethereum adding RISC-V (or something else we decide on) as a canonical ISA - a big decision that should be done carefully, but that I think will be necessary to drive Ethereum forward.

这个有点东西！券商金工研报里那套压箱底的选股/因子策略，全被人用 Python 复现出来了 QuantsPlaybook，6K stars，华泰/中信/招商/国信 100+ 策略免费抄作业，A股直接跑！ 核心很直接：文件夹里丢原研报，旁边是复现代码。窗口、回测、画图都能改。数据走聚宽 jqdata 和 Tushare。 核心亮点： 1️⃣ 100+ 券商金工策略，华泰/中信/招商/国信等头部券商研究成果全复现，6K stars 同类断层第一 2️⃣ 经典策略一个不落：RSRS 择时、QRS、HHT、FScore、神奇公式、凸显性因子 STR、球场寻位因子 3️⃣ 四大类全覆盖：25+ 选股 + 22+ 因子 + 基本面价值 + 组合优化（DE 进化算法、多任务学习） 4️⃣ 每个策略配 A股真实数据回测，年化/回撤/夏普/胜率报告都给你算好 5️⃣ Qlib + Backtrader + LightGBM 全套框架，聚宽/tushare 双数据源，1.4K forks 以前想看券商金工研报，要么没渠道、要么只有 PDF 没代码，想复现 RSRS、FScore 这些经典策略还得自己一行行敲。 QuantsPlaybook 不一样，头部券商金工团队的研究成果，全被拆成能跑的 Jupyter notebook，6 年攒了 100+ 个，国内同类找不出第二个。 别人还在付费买研报、手动抄公式，你直接 clone 下来抄作业。