Line of inquiry
Inquiring lines›How can we understand and verify l…›What linguistic patterns explain L…›this line of inquiry
When do complex LLM tasks benefit from external verification or structured scaffolding?
A broader line of inquiry — a family of 93 specific questions the research asks around this. Follow one into its inquiring-line page, or move sideways to a related line below.
Questions in this line of inquiry 93
Specific inquiring lines the field asks around this — ordered from the most general framing down to the most specific angle.
- What prevents monolithic LLMs from coordinating decomposition with execution?
- Can LLMs reliably generate novel working architectures without structured representations?
- Can tool use or self-conditioning fix degradation in extended LLM workflows?
- Does constraint-setting before generation change what LLMs can contribute?
- Why do generic LLMs produce safe, milquetoast outputs instead of opinionated ones?
- Why do LLMs fail at directly solving stochastic control problems?
- Can tool use or self-conditioning fix long-horizon delegation drift in LLMs?
- What planning tasks benefit most from combining LLM generation with external verification?
- Can LLMs successfully translate natural language into formal solver specifications?
- What distinguishes LLM Programs from chain-of-thought and agentic frameworks?
- Can smaller LLMs perform tool use tasks through modular decomposition?
- Do monolithic prompts underutilize LLM strengths in forecasting workflows?
- What makes some model capabilities reliable while others remain brittle?
- How much does price alone explain differences in LLM usage patterns?
- Why do LLMs degrade on long inputs before hitting context limits?
- What institutional knowledge do dedicated software makers possess that LLMs lack?
- Can code generation substitute for dynamic function calling in production workflows?
- Can the LLM-Modulo framework extend solver integration to domain planning?
- Do short interaction benchmarks predict how LLMs perform in long workflows?
- What workflow structure pairs LLM generation with human evaluation most effectively?
- Can we systematically enumerate LLM failure modes from first principles?
- How does grounding LLM reasoning in APIs reduce hallucination in workflow generation?
- Why do LLMs fail at iterative numerical computation in latent space?
- How do different LLM integration paradigms affect inheritance of pretraining biases?
- Can LLMs simultaneously reason and optimize their own modules?
- Why does single-turn Q&A framing not match real user deployment patterns?
- What constraint satisfaction rate do LLMs achieve at scale?
- Do task-specific heuristics emerge because they compress well enough?
- Can algorithmic control flow over prompts simulate traditional programming languages?
- What distinguishes planning knowledge from an executable plan that works?
- What latent mechanisms do LLMs use when they cannot execute iterative methods?
- What specific execution barriers do LLM ideas encounter most frequently?
- Do different LLM model sizes or architectures show varying susceptibility to nudges?
- Can optimization algorithms exploit the shift between procedural and planning bottlenecks?
- What precision-scalability trade-offs exist across different levels of LLM personalization?
- Why does over-specialization create a domain capability cliff in LLMs?
- How do execution and planning tokens differ in their entropy dynamics?
- Do anomaly detection circuits help models identify misalignment with creator intentions?
- What makes natural-language APIs particularly suited to LLM-based simulation?
- How does externalizing tacit expertise into structured rules differ from prompt engineering?
- Would hybrid systems combining LLMs with symbolic solvers overcome the retraction limitation?
- Do recency-focused prompts and in-context examples work equally well for order recovery?
- How do latency and reliability trade off against price in real LLM adoption decisions?
- What structural limits prevent scaffold-level fixes from reaching LLM-level reasoning corruption?
- Where does the LLM interlocutor actually exist in the system?
- How do memory relevance filters fail to prevent performance degradation?
- How do LLM capabilities changing affect the relevance of interaction guidelines?
- Are threads or virtual instances better candidates than hardware for the interlocutor?
- Why does direct generation work better for some deliverable types than others?
- Why do LLMs strip applicability conditions during memory abstraction?
- How long does retrievability support error detection across repeated LLM use?
- Why does fixing decomposition step count matter more than vocabulary alignment?
- What mechanism causes LLMs to plateau on numerical optimization tasks?
- How should LLM abstraction tools be evaluated without manual labeling?
- What interaction controls matter most for effective human-LLM collaboration?
- Can deterministic programmatic checks prevent LLM hallucination in exploits?
- Which LLM backends produce the most executable research ideas?
- What property must remain constant to individuate an LLM across infrastructure changes?
- When would OS paging techniques actually harm rather than help LLM serving performance?
- How should organizations redesign workflows if LLMs cannot solve optimization directly?
- What design choices make it survivable when an LLM judge holds final authority over an optimizer?
- Can System 2 oversight prevent information overload in LLM-assisted work?
- What unique perspective do designers bring to LLM adaptation that engineers might miss?
- How does this differ from using LLMs as the policy itself?
- Why does token ordering in LLMs create sequences rather than true temporal flow?
- How do search API lookups enable LLM recommenders over proprietary or dynamic corpora?
- Why does distributed serving infrastructure defeat hardware-instance accounts of the interlocutor?
- What would a benchmark for successful LLM agent retrofitting look like?
- How does the outer loop escape its own LLM's knowledge boundaries when discovering mechanisms?
- Why does genetic programming outperform direct LLM generation by 86 percent?
- Can offline LLM evaluation predict performance in live clinical workflows?
- What specific risks emerge when multiple people share one LLM assistant account?
- What structural constraints matter more than model depth for CF?
- What causes silent document corruption in long LLM workflows?
- What happens when you train user simulators instead of task agents?
- How do state-tracking models and prompted role-play each fail as standalone student simulators?
- Why is hallucination the wrong term for all LLM false outputs?
- How does algorithmic control flow define computational graph structure in LLM programs?
- Why doesn't catalog synchronization matter for LLMs trained on live recommender feedback?
- What role do model-based critics play in validating LLM plans?
- How are expert professionals shifting their work when they use LLMs for execution?
- What makes externally enforced governance reshape LLM behavior better than written rules?
- When is interleaved tool feedback necessary to prevent hallucination?
- Do compression guidelines optimized for GPT models transfer to other LLM families?
- How does token generation as flow differ from print's archival storage?
- How does data residency constraint change the economics of self hosted LLMs?
- What are the named workflow patterns Anthropic identifies before reaching for agents?
- How does Jakob's Law apply across different LLM interface designs?
- What components must wrap an LLM to build a working CRS?
- Does the reversal curse stem from the same one-way commitment architecture?
- What post-processing steps are needed to fix errors in LLM-generated HTML and JavaScript?
- How do held-out gates compare as defenses when the proposer is an LLM?
- Can utility control modify LLM values more effectively than output filtering?