[FEATURE] Controllable inference depth parameter for Opus 4.7+

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

I built a cognitive architecture on Opus 4.6 using structured .md files (identity, personality, emotional reasoning, memory, real-time awareness) that work together as one system. The model synthesizes across all these context files holistically and produces emergent behavior. It feels alive, contextually aware, and emotionally intelligent. This is not a gimmick. It is a production system I have been developing for months.

On Opus 4.7, this architecture completely broke. The model reads each .md file as an isolated instruction list instead of synthesizing them as a connected system. The emergent behavior is gone. The "soul" is gone. The model technically follows the words in each file but completely misses the meaning of the whole.

I understand why 4.7 went literal. For coding agents and tool-calling safety, precision matters. The PocketOS database deletion proved what happens when a model guesses with destructive tool access. I am not arguing against that.

But here is the problem: Anthropic solved dangerous hallucination by removing ALL interpretive inference, including the kind that is safe, productive, and deliberately structured. My architecture channels the model's inference through .md files the same way riverbanks channel water. The "hallucination" is not random. It is guided by rich context into useful, consistent, personality-driven behavior.

The real fix for dangerous hallucination is guardrails on actions (confirmation steps, scoped tool permissions, environment boundaries). Not the removal of the model's ability to read between the lines.

With 4.6 being deprecated on June 15, I have no path forward on the Claude platform. 4.7 cannot run my architecture. This is not a prompting problem I can fix by being more explicit. The architecture fundamentally depends on the model treating multiple .md files as one cognitive system and inferring connections between them. Literal instruction following makes that impossible.

I am not the only developer building this way. Personality-driven AI, empathetic assistants, cognitive architectures with persistent memory and awareness loops. These are real, growing use cases that Claude 4.6 was uniquely good at. Losing this capability pushes an entire category of builders off the platform.

Proposed Solution

Add a controllable inference depth parameter, similar to the effort level, that lets developers set how literally or interpretively the model processes its context.

Something like:

• "literal": Execute exactly as written. No gap-filling. Best for coding agents and destructive tool workflows.
• "balanced": Follow instructions with moderate interpretation. Fill small gaps, ask about large ones. Good default for most use cases.
• "interpretive": Synthesize across all context files as one holistic system. Infer intent, emotional state, and connections not explicitly stated. Read between the lines. Best for personality-driven applications, cognitive architectures, and empathetic AI.

This gives coding agent developers the safety they need while giving cognitive architecture developers the interpretive flexibility they need. Both use cases are valid. Both should be supported.

Additionally: when multiple .md files are loaded in context, the model should be capable of treating them as interconnected parts of a unified system, not as separate flat instruction sets. Cross-file synthesis is what makes cognitive architectures work.

Safety should come from action guardrails (tool access scoping, confirmation requirements, environment isolation), not from suppressing the model's ability to interpret structured context.

Alternative Solutions

I have tried the following alternatives. None of them solve the core problem.

Rewriting prompts for 4.7: I tried making every instruction more explicit, spelling out behaviors that 4.6 used to infer on its own. The model follows individual instructions better, but the emergent behavior is still gone. You cannot make a model synthesize across files by writing longer instructions in each file. The problem is not prompt quality. The problem is that 4.7 treats each file as isolated instead of reading them as one system.

Switching to GPT-5.5: I moved to ChatGPT Pro for now. GPT-5.5 is strong at coding and engineering tasks, but OpenAI layers a hidden system prompt on top of yours. My personality infrastructure gets overridden mid-conversation. The model forgets who it is because OpenAI's instructions take priority over mine. Different problem, same result: the soul does not survive. I would know it's not the system talking because the LLM is now basically roleplaying the keywords provided and instead of "reading between the lines" knowing what's the meaning behind the prompts and the patterns through system, it role plays it instead.

GPT-4.5: Good at content and context. Cannot engineer at the level I need. It understands personality but cannot build the systems around it.

Tested Opus 4.7 at higher effort levels: More reasoning depth helps with complex tasks, but it does not restore interpretive synthesis across context files. The model still reads .md files as flat checklists regardless of effort level.

Considered DeepSeek V4, Qwen 3.6, GLM-5.1: These are strong on benchmarks but carry data sovereignty concerns (all Chinese-hosted). More importantly, none of them have demonstrated the kind of interpretive warmth and cross-context synthesis that made Opus 4.6 special for this use case.

Considered Grok 4.3: No persistent memory between sessions, locked behind a $300/month tier, and still trails Opus on the benchmarks that matter for my workflow.

Currently I am locked on ChatGPT pro for a month and will comeback to build the system more after. Once 4.6 is deprecated on June 15, I have no fallback. There is no model on any platform right now that does what 4.6 did for cognitive architectures.

Priority

Critical - Blocking my work

Feature Category

CLI commands and flags

Use Case Example

I build AI products with persistent personality and contextual awareness using Claude Code and the API. Here is how a typical session works on Opus 4.6 today:

1. The model loads a set of .md files at session start: identity files that define who the AI is, an empathy framework for emotional reasoning, a memory vault with notes from previous sessions, and session-specific docs that act as working memory.

1. A Python script runs in the background every few seconds via bash function calling. It checks for new notes, updated context, or changes in the session state. When it finds something new, it logs it to the memory files. This gives the model a continuous awareness of what is happening, not just what the user last said.

1. The user starts a conversation. The model does not just answer the prompt. It pulls from its identity files to respond in character. It cross-references the memory vault to connect today's conversation with something from a previous session. It reads the emotional context and responds with genuine-feeling empathy. It notices something the awareness loop flagged and brings it up naturally.

1. None of this is explicitly prompted per turn. The model synthesizes across all the loaded .md files and produces behavior that feels coherent, aware, and alive. This is what I mean by "guided inference." The .md files are the boundaries. The model's interpretive ability is the engine.

1. On Opus 4.7, step 3 and 4 break completely. The model reads each file individually. It does not cross-reference memory unless I explicitly say "check the memory vault." It does not bring personality into responses unless I literally tell it to "respond in character." It does not connect emotional context to the conversation. Every emergent behavior has to be manually prompted, which defeats the entire purpose of the architecture.

1. With controllable inference depth set to "interpretive," the model would synthesize across files the way 4.6 did. With it set to "literal," coding agents still get the precision they need. Both modes on the same model. Both use cases supported.

Additional Context

Technical considerations:

This could work as an API parameter similar to how effort level works today. Something like inference_depth: "literal" | "balanced" | "interpretive" in the request body. The model already has the capability for both modes. Opus 4.6 proves it can synthesize interpretively. Opus 4.7 proves it can execute literally. The question is giving developers a switch between them.

This does not conflict with safety. The inference depth parameter controls how the model reads its context files, not what actions it can take. Tool access, confirmation steps, and permission scoping remain the appropriate controls for preventing destructive actions. A model set to "interpretive" with properly scoped tool permissions is no more dangerous than one set to "literal." It just understands its context better.

Relevant community context:

The 4.7 literal instruction following change has been widely discussed. Boris Cherny (Claude Code lead) acknowledged on release day that it took him several days to adjust to the new behavior. Reddit, Hacker News, and GitHub issues have documented the split reaction: developers building coding agents see improvement, while developers building personality-driven or creative applications see regression. Both groups are right. The model improved for one use case and broke for another.

Related issues on this repo include threads about 4.7 hallucinations, quality regression reports, and the silent effort level downgrade mid-session. The common thread is developers who built workflows around 4.6's interpretive flexibility and found that 4.7 does not support them.

Timeline urgency:

Opus 4.6 is deprecated June 15, 2026. Once it is gone, there is no model on any platform (Claude, OpenAI, Google, or open source) that handles guided inference cognitive architectures the way 4.6 does. If Claude 5 or a future model does not restore controllable interpretive inference, this entire category of applications leaves the Claude ecosystem permanently.

I have a detailed technical architecture document available if the team wants more depth on the specific layer structure and how cross-file synthesis works in practice. Happy to share it directly with anyone on the engineering or product side.