35,595 results · Most relevant
Real pull occurs when someone has a project on their to-do list, is trying to do it right now, but cannot do it with their existing tools, methods, or options. The pull framework describes a person who would be weird not to buy your product — someone who will pull your product out of your hands.
In the PULL acronym, P stands for Project (the person has a project on their to-do list, like a job to be done — not 'I want to buy recruitment software' but 'I want to hire more employees'), U stands for Unavoidable (the thing they have to do right now, not later), the first L stands for List of options (hiring somebody, having the existing team do it, using tools they already have, or tools on the market), and the second L stands for Limitations (why those existing options are not good enough).
Rob Snyder defines a hell yes customer as somebody who pulls the product out of your hands before they buy, and afterwards uses it as if it is addictive. What matters is that they're weird not to buy and weird to churn, and the process is mostly them pulling versus you pushing.
Rob Snyder applies bottleneck thinking to sales: if the bottleneck is not enough pipeline, then that's the only thing that matters right now — solve that bottleneck, then move to the next one. If the close rate is lower than it should be, that's the bottleneck — go all in on that. When 90%+ of customers are churning, figure out whether the cause is something you're doing or something about them — that tells you who actually had pull you can sell, deliver, and retain.
Consequential creator advice requires independent verification before Today can promote it.
Rob Snyder describes the case study factory as having three steps: the pipeline step (how do we get people to talk to us), the sales step (how do we turn potential customers into actual customers), and the delivery step (how do we get customers to be weird, not to churn).
A naive post-filtering strategy retrieves the closest vectors (e.g., 10,000) and then throws away the ones that don't match permissions. This does not work well: the search spirals outward and must give up after a couple of seconds, having found only e.g. 40 of the top 100 matching documents, yielding very poor recall. Post-filtering makes users unhappy because they may know a matching document exists (e.g., maroon sandals when searching red shoes) but it doesn't turn up; a user who only has access to a subset of the data still wants to see the documents closest to the query from their perspective, including the results they can see.
An alternative to post-filtering is to start with the filters instead of the vector index: turbopuffer builds an index of all the documents that match the filters, then scans over those documents to see which are closest to the query vector. But if a user has access to 50 million out of 100 million documents, pre-filtering alone regresses to the original problem: scanning takes multiple seconds if not minutes, and the vector index isn't actually being used. Pre-filtering alone doesn't work well because it finds all docs matching the filters and then scans through them sequentially, never actually using the vector index.
A first challenge is having the wrong source, e.g., pulling from Seeking Alpha or a random blog claiming Palantir will be worth $100,000 a share. A second is having the right source but the wrong number, e.g., seeing 17 in a 10K/10Q without knowing if it's 17 million, 17 billion, a currency figure, a year, or a page number. Models are also not actually doing math in a way that ensures fidelity and accuracy, though in some cases they write code that does do math.
In production, Kepler refuses citations that can't be verified — if a number isn't cited, the model is structurally incapable of producing that output. The citation filter has correctly extracted about 21,000 citations. By checking against sources, Kepler has effectively created a ground truth retrieval engine across any corpus of data, including public equities and internal data.
citation count is approximate and flagged as a possible numeric error
Kepler's core guarantee: the model never writes a number itself; it must cite one. A post-processing step makes the model structurally incapable of writing something it cannot cite, so while the model can still hallucinate, the platform cannot produce hallucinated numbers.
The speakers argue that the real unit of analyst work is large — a PM gives an analyst a fund's mandate and a company, and the resulting work (mandate to investment memo) can take 20 to 100 analyst hours. Benchmarks should be sized to this real unit of work.
MandateBench is designed to explicitly grade the reasoning path of an investment memo rather than only the final call, using a rubric where each key reasoning step is a node in a reasoning graph.
A browser on your laptop has an entire fingerprint: browser version, OS, fonts, screen size, and even time zone. Websites also see a familiar visitor pattern (prior visits, cookies, logins, repeated bookings) and each request goes through a network with a network reputation, so the visitor is clearly human. Problems appear when you put the same version of Chromium into a data center: a launched headless browser in an EC2 instance gets a fresh fingerprint, fresh cookies, may need to log in again, and its proxies are a clear indicator of a data center rather than a residential IP.
Voss argues that speeding up code generation without speeding up code review does not increase shipping speed — the constraint is the bottleneck. A 10,000-line diff takes about a week to review at ~450 LOC/hour, so teams should plan merge cadence around that reality.
If the useful life of a weight file is about two years, inference flops should be considered roughly 12x more important than training flops; when writing papers or selecting models, minimize train flops but care about inference flops roughly 12x more.
SGLang's overlap scheduling delays device-to-host synchronization for another round so that there are no blocking operations in the critical path.
Many quantization recipes require training the model after quantization, but Together doesn't like using them. Post-quantization training requires the entire original training dataset, so unless you're the model provider yourself, you can't do it — and it can cause the model to forget things. Together's quantization is entirely a training-free approach, involving calibration data and the Scale Search paper.
With 72-GPU high-bandwidth racks, you can put each expert of a model individually onto different GPUs (expert parallelism). Placing experts on separate GPUs lets you serve much higher volumes on the same GPU hardware, because when one expert sits on a GPU serving many tokens, the workload looks like a big matrix multiply, which GPUs are very good at. Expert parallelism ideas have been known for a couple of years, with demos findable from two to three years ago.
There are roughly six things you can use to make inference faster: kernels, disaggregation, parallelism, routing, speculative decoding, and quantization. Kernels are where the model actually runs on the GPU and can be optimized by writing different attention kernels, MoE kernels, or mega kernels; kernels matter most at the core pre-fill and decode parts of the computation.
Dr. Scott Forbes explains that creatine, once inside a cell, is degraded into creatinine, which enters the bloodstream. Doctors commonly assess kidney function by measuring creatinine and treat elevated creatinine as a red flag. Taking creatine elevates creatinine levels, which doctors may misinterpret as kidney dysfunction — but creatine does not damage your kidneys; it's often just a misinterpretation.
Choose sources → to get a library of your own and a daily brief.