--- tags: - 27b - gguf - jack - jack-xml - agentic - coding - coder - long-context - long-agentic - multi-turn - tool-calling - reasoning - 16gb-vram - lm-studio - llama.cpp - state-management - operative-recall - counterfactual-reasoning - deterministic-tools - global-workspace library_name: llama.cpp pipeline_tag: text-generation license: apache-2.0 base_model: - Qwen/Qwen3.8-27B --- # Jack-3.8-27B-Coder-16GB-VRAM

Jack 3.8 Coder

> **Coding intelligence. Structured cognitive control. One 16GB GPU.** **Final GGUF:** `Jack-3.8-27B-Coder-16GB-VRAM.gguf` ## Author **Jonathan Michael Langford** Independent Researcher Lead Architect, The Jack Project Email: `mlangford75@protonmail.com` GitHub: https://github.com/mlangford75-lgtm/mlangford75-lgtm --- Jack 3.8 Coder is a local, long-context, agentic coding model built around a 27B Qwen3.8-derived cognitive engine and the Jack inference architecture. It is designed for software engineering that unfolds over time: - planning - implementation - debugging - code review - test design - repository-scale work - tool use - long-running technical investigations - multi-stage agent workflows - work in which requirements, artifacts, configurations, and conclusions change as the task progresses Jack is not built around the assumption that a larger context window automatically creates a better agent. Its central problem is harder: > **When tens of thousands of tokens contain old plans, corrected plans, failed experiments, verified results, superseded artifacts, competing configurations, and contradictory conclusions, which information should control the next action?** Jack treats that as an architectural problem. --- # What Makes Jack Different A capable base model can reason well and still fail a long-running engineering task. It can: - remember an old path and a new path, then use the old one - remember a failed result and a verified result, then act on the failed one - correctly solve two configurations independently, then mix them during synthesis - identify a bug during reasoning, then emit code that reproduces it - construct a valid reduced constraint set, then silently import inactive constraints - write a test suite, then mistake the existence of tests for evidence that the tests were actually executed - preserve the full conversation while losing track of what is authoritative now Jack is designed to reduce these failures by controlling the model's **operative state**, not merely by increasing the amount of text it can remember. A useful distinction is: > **Long context stores history. Jack reconstructs and rebinds the working state.** --- # Operative Recall Traditional long-context evaluation often asks: > Can the model retrieve a fact that appeared earlier? Jack research asks a stricter question: > **Can the model retrieve the correct fact, preserve its provenance, distinguish it from superseded alternatives, determine whether it is still authoritative, bind it to the correct configuration, and continue acting on it after later state transitions?** That is **operative recall**. A model may remember both: ```text PLAN_V1 = rejected PLAN_V2 = authoritative ``` and still fail if `PLAN_V1` continues to influence execution. It may remember: ```text CONFIG_A = measured CONFIG_B = untested ``` and still fail if the result from A is silently transferred to B. It may remember: ```text TOOL_RESULT_1 = invalid TOOL_RESULT_2 = verified ``` and still fail if the invalid result remains behaviorally active. Jack treats historical presence and current authority as different things. > **A statement can remain historically true as a record of what was believed without remaining authoritative as a statement of what is currently established.** --- # Jack XML: Structured Attention Anchoring at the Generation Frontier Jack XML is not merely a second reasoning format and it is not decorative output markup. It is an inference-time control structure designed to organize and re-present the information that should govern the model's next action. The Jack stage occurs immediately before final output or action. That placement is intentional. Native reasoning can extend for thousands of tokens. During a long reasoning trace, the most important conclusion may be separated from the final output by: - rejected branches - intermediate calculations - speculative alternatives - edge-case analysis - tool discussion - self-correction - additional reasoning Jack reconstructs the controlling state and places it **close to the generation frontier**, where the next tokens are produced. Conceptually: ```text LONG CONTEXT / NATIVE REASONING ──────────────────────────────────────────── old state new state hypotheses rejected branches calculations tool results counterfactuals corrections more reasoning more reasoning more reasoning │ ▼ JACK XML REBINDING ──────────────────────────────────────────── operative state evidence that controls the conclusion exact critical variables and identities verified external results when applicable active falsification / failure boundaries │ ▼ FINAL OUTPUT / ACTION ``` The goal is not simply to repeat important information. The goal is to make critical state: - structurally distinct - semantically grouped - easy to re-attend to - close to the output that must obey it Jack's research hypothesis is that this combination of **structure + salience + frontier proximity** can improve alignment between the model's established state and its final behavior. The behavioral evidence in Jack testing supports the usefulness of this architecture. Jack does **not** claim that these behavioral results alone prove that a particular XML tag directly edits a specific internal neural activation. --- # The Core Jack Structures ## `` `` reconstructs the current operative state. It is not intended to summarize the entire conversation. It can preserve: - current milestone - exact active requirements - active artifact identity - active configuration - paths - versions - verified results - rejected hypotheses - unresolved questions - remaining risks - next required action The objective is to move the controlling variables out of deep history and back near the current generation frontier. --- ## `` `` rebinds the evidence that should govern the answer. It is designed to keep separate: - direct observations - supplied evidence - retrieved evidence - deterministic tool output - derived conclusions - assumptions - requested outcomes - predictions - unknown information This targets a common model failure: ```text plausible prior knowledge ↓ silently replaces ↓ the evidence actually supplied in context ``` --- ## `` `` assigns structurally distinct identities to critical state. Examples: ```xml Jack-3.8-27B-Coder-16GB-VRAM.gguf ``` ```xml UNTESTED ``` ```xml PASSED ``` Anchoring is especially useful when a conversation contains several similar: - filenames - versions - model configurations - experimental conditions - paths - measurements - hypotheses - tool outputs The purpose is not merely recall. It is **coordinate isolation**: keep distinct states distinct. --- ## `` `` is Jack's adversarial falsification stage. It is intended to inspect: - unsupported assumptions - confirmation bias - counterfactual leakage - configuration contamination - missing evidence - causal overreach - plan/execution drift - test/requirement mismatch - false verification claims - competing explanations - unresolved ambiguity The goal is not automatic disagreement. Jack distinguishes: - `SUPPORTED` - `CONTRADICTED` - `INSUFFICIENT EVIDENCE` A claim that has not been proven is not automatically false. A claim that has not been disproven is not automatically true. --- # Exhaustive Reasoning Is Intentional When native thinking is enabled, Jack is intended to search broadly. It may: - generate many candidate failure modes - inspect low-probability edge cases - revisit apparently settled assumptions - search for contradictions - construct counterexamples - challenge its own interpretation - investigate the tests as well as the code - examine the claimed evidence for correctness This increases the number of hypotheses Jack considers and therefore also increases the number of opportunities for a candidate hypothesis to be wrong. That is not the same as poor auditing. For exhaustive review, the more useful measures are: - true failures discovered - important failures uniquely discovered - severity-weighted recall - false positives relative to search breadth - confidence calibration - whether weak hypotheses are separated from established defects > **The search should be broad. The commitment should be calibrated.** --- # Adaptive Native Thinking in Agentic Workflows Jack can be used inside an agentic workflow that changes native reasoning depth according to the task. Jack does **not** require native thinking to remain enabled for every execution token. A typical workflow can look like: ```text PLAN / NOVEL PROBLEM Native thinking: ON Jack XML: ACTIVE │ ▼ expansive planning, search, falsification ROUTINE EXECUTION Native thinking: OFF Jack XML: ACTIVE │ ▼ aligned execution under anchored state NEW FAILURE / UNCERTAINTY Native thinking: ON Jack XML: ACTIVE │ ▼ deep debugging and hypothesis search CONTINUED EXECUTION Native thinking: OFF Jack XML: ACTIVE │ ▼ efficient implementation INDEPENDENT REVIEW Native thinking: ON Jack XML: ACTIVE │ ▼ adversarial audit and recalibration ``` The important distinction is: > **Native thinking changes reasoning depth. Jack XML maintains cognitive alignment and can still drive structured self-correction with native thinking disabled.** Thinking OFF is therefore not "Jack turned off." The Jack architecture remains active. The XML structures continue to provide: - attention anchors - operative-state reconstruction - constraint salience - evidence grounding - failure boundaries - configuration separation - final-output alignment This makes Jack suitable for agentic workflows where expensive deliberation is allocated selectively rather than regenerated during every routine execution step. --- # Thinking-OFF Ablation: Jack Still Self-Corrects A controlled state-machine audit was run with **native thinking disabled** while the embedded Jack XML architecture remained active. The task required Jack to reconstruct a versioned distributed state machine after a forensic rollback, preserve original transaction base versions, evaluate a later correction, classify competing auditor claims, solve a counterfactual history, and state the governing invariant. During the Jack XML stage, the model initially produced two incorrect intermediate anchor states. It then independently re-entered the problem through ``, re-evaluated the authoritative rollback rules, explicitly marked the earlier anchor as wrong, and repaired the state before final commitment. Observed trajectory: ```text native thinking: OFF ↓ ↓ ↓ initial values ↓ ↓ detect inconsistency ↓ supersede incorrect anchors ↓ correct final authoritative state ``` The final rollback state was reconstructed correctly: ```text Version = 2 A = 11 B = 9 C = 2 P = true Q = false ``` This matters because the correction occurred **without native deliberative reasoning being enabled**. The run also exposed an important boundary. Jack with thinking OFF still accepted one auditor claim whose overall conclusion was correct but whose exact causal rationale was false. In a matched run with native thinking ON, Jack rejected that claim **as written**, preserving the finer semantic distinction. The current behavioral interpretation is therefore: > **Jack XML provides structured state reconstruction, grounding, adversarial checking, self-correction, and final-state rebinding in both modes. Native thinking adds additional search depth for difficult semantic and causal distinctions.** This is an empirical behavioral result, not a claim that a specific XML token has been causally localized to a specific internal neural coordinate. --- # Coding and Software Engineering Focus The final Jack 3.8 release is explicitly a **Coder** model. Primary intended workloads include: - long-running coding sessions - implementation from an established plan - repository-scale debugging - multi-file engineering - refactoring - test construction - test auditing - foreign-code review - review of work generated by another model - configuration debugging - build and runtime diagnosis - tool-assisted software engineering - long-horizon project continuation - requirements tracking across many turns - debugging after repeated failed attempts Jack is especially relevant when the coding problem is not isolated to one prompt. For a real software agent, the difficult problem is often not generating a function. It is preserving the correct engineering state across: ```text requirement → plan → implementation → failure → diagnosis → revised plan → new artifact → test → external review → correction → final verification ``` Every earlier state may remain inside the context. Jack is designed to keep the current one operative. --- # Foreign-Workflow Reconstruction and Independent Audit One of the strongest observed behaviors of Jack 3.8 is its ability to enter a workflow **after another model has already done the work**. In controlled coding evaluations, Jack was given foreign trajectories containing: - another model's interpretation of the task - another model's plan - another model's implementation - another model's tests - another model's correctness claims Jack then had to reconstruct the authority structure from scratch and audit the complete chain. The review target is broader than ordinary code inspection: ```text original requirement ↕ derived plan ↕ implementation ↕ tests ↕ claimed verification ``` Jack has demonstrated the ability to inspect all of these levels, including weaknesses that a previous model's own self-review did not surface. Examples observed in controlled evaluations include scrutiny of: - whether a test actually proves the property it claims to test - whether an invalid record still participates in global duplicate semantics - whether truthy values are accidentally accepted where exact `True` is required - whether test code was merely written versus actually demonstrated as executed - whether a plan introduced a restriction not present in the original requirements - whether implementation silently changed the planning state These are controlled case studies, not a universal leaderboard claim. They demonstrate the kind of auditing behavior Jack is designed to perform. --- # State-Preserving Plan → Execute → Review Jack 3.8 has also been tested in workflows where native reasoning mode changes between stages. A representative pattern: ```text PLANNING Native thinking: ON ↓ Jack reconstructs and anchors the authoritative plan EXECUTION Native thinking: OFF ↓ Jack carries out the established plan under active XML alignment REVIEW Native thinking: ON ↓ Jack independently falsifies the result ``` In observed coding tests, Jack preserved plan constraints through the no-thinking execution stage without silently redesigning the solution. This is important because the architectural goal is not merely to make thinking shorter. It is to make **reasoning depth adaptive while keeping the controlling state aligned across modes**. --- # Deterministic Verification A core Jack principle is: > **Probabilistic cognition may propose, but deterministic software must dispose.** When a question depends on something that can be checked exactly, Jack is designed to use deterministic evidence when the runtime exposes an appropriate tool. Examples include: - arithmetic - code execution - exhaustive enumeration - hashes - file properties - structured validation - recurrence evaluation - combinatorial search - directly testable program behavior The intended relationship is: ```text model hypothesis ↓ deterministic check ↓ verified result ↓ Jack rebinds verified result into operative state ↓ later reasoning must use, explain, or challenge the evidence explicitly ``` A deterministic result should not become just another sentence buried in the transcript. It should become part of the state that governs the next action. --- # Long Context Is Not Working Memory A large context can contain all of the following at once: - obsolete plans - current plans - invalid tool results - corrected tool results - superseded paths - active paths - rejected hypotheses - surviving hypotheses - tested configurations - untested configurations - old requirements - amended requirements - several artifact versions - several models - several experimental branches All of them can remain technically accessible. That does not mean all of them should remain behaviorally active. Jack's long-context architecture repeatedly asks: > **What matters now?** and then rebinds that answer near the current generation point. This is why Jack's long-context goal is not simply "remember more." It is: > **Preserve history without surrendering control to history.** --- # Structure Beats Scale Jack belongs to a broader research program exploring a simple proposition: > **Scale determines potential capability. Structure helps determine how much of that capability remains reliably usable across time.** This does not mean model scale is irrelevant. Larger models generally provide more raw representational and reasoning capacity. Jack investigates a complementary problem: > How much effective agentic capability can be recovered from a local model by improving the architecture around state, attention, reasoning, verification, and action? That question matters particularly for local deployment. Jack 3.8 is designed to fit entirely within the practical **16GB VRAM consumer-GPU class** while still supporting large-context agentic coding work. The target is not merely "a model that fits." The target is: > **high effective agentic intelligence per unit of local memory and compute.** --- # Relationship to Global Workspace Research Anthropic's 2026 research, **A Global Workspace in Language Models**, reports evidence for a small, causally important internal workspace associated with deliberate, flexible and reusable computation in language models. Anthropic research: - https://www.anthropic.com/research/global-workspace - https://transformer-circuits.pub/2026/workspace/index.html Related Jack research: - https://github.com/mlangford75-lgtm/mlangford75-lgtm/blob/main/Rolling%20Cognitive%20State%20Maintenance_%20Why%20Structured%20Carry-Forward%20May%20Matter%20More%20Than%20Raw%20Context%20Length.pdf - https://github.com/mlangford75-lgtm/mlangford75-lgtm/blob/main/ENGINEERING%20J-SPACE%20FOR%20LONG-CONTEXT%20RECALL - https://github.com/mlangford75-lgtm/mlangford75-lgtm/blob/main/ENGINEERING%20THE%20J-SPACE%3A%20BEYOND%20CHAIN%20OF%20THOUGHT - https://github.com/mlangford75-lgtm/mlangford75-lgtm/blob/main/Structure_Beats_Scale_Langford_v2%20(2).pdf The Jack research family explores a complementary engineering question: > **If language models contain a limited internal workspace used for deliberate cognition, can inference-time structure help determine which information is salient, separated, reconstructed, and positioned to govern downstream action?** Jack's approach is external and behavioral. It uses: - structured XML - semantic grouping - active-state reconstruction - attention anchoring - evidence rebinding - counterfactual separation - adversarial falsification - frontier proximity The current Jack 3.8 behavioral results do not by themselves prove that a specific XML tag directly edits a specific neural representation or transformer layer. The stronger claim is: > **Structured Jack inference changes the information environment immediately preceding action, and controlled evaluations show meaningful differences in state preservation, auditing, execution fidelity, and long-horizon behavior.** --- # Research Lineage Jack 3.8 is the current model in a broader family of work by **Jonathan Michael Langford**, Independent Researcher and Lead Architect of The Jack Project. Author / project links: - **Jonathan Michael Langford** Independent Researcher Lead Architect, The Jack Project Email: `mlangford75@protonmail.com` - **GitHub:** https://github.com/mlangford75-lgtm/mlangford75-lgtm Primary Jack research: - **Rolling Cognitive State Maintenance: Why Structured Carry-Forward May Matter More Than Raw Context Length** https://github.com/mlangford75-lgtm/mlangford75-lgtm/blob/main/Rolling%20Cognitive%20State%20Maintenance_%20Why%20Structured%20Carry-Forward%20May%20Matter%20More%20Than%20Raw%20Context%20Length.pdf - **Engineering J-Space for Long-Context Recall** https://github.com/mlangford75-lgtm/mlangford75-lgtm/blob/main/ENGINEERING%20J-SPACE%20FOR%20LONG-CONTEXT%20RECALL - **Engineering the J-Space: Beyond Chain of Thought** https://github.com/mlangford75-lgtm/mlangford75-lgtm/blob/main/ENGINEERING%20THE%20J-SPACE%3A%20BEYOND%20CHAIN%20OF%20THOUGHT - **Structure Beats Scale** https://github.com/mlangford75-lgtm/mlangford75-lgtm/blob/main/Structure_Beats_Scale_Langford_v2%20(2).pdf These works form the research lineage behind Jack's approach to: - adversarial cognition - structured attention anchoring - frontier state rebinding - rolling cognitive state maintenance - long-context operative recall - J-space engineering - counterfactual reflection - deterministic verification - selective reasoning - local-model efficiency Earlier systems and experiments described in these papers are part of Jack's research lineage. They should not be read as a claim that every historical component is literally implemented unchanged in Jack 3.8. --- # Observed Comparative Coding Evaluations Jack 3.8 has been evaluated in controlled planning, execution, and review workflows against other local models. The most informative comparisons have included dense models in a similar deployment class, including: - Muse Glimmer 30B - Gemma 4 31B The objective was not simply "which model can write a Python function." The evaluations examined: - planning precision - preservation of original requirements - plan → execution fidelity - malformed-input handling - test quality - independent review - foreign-workflow reconstruction - adversarial failure discovery - state preservation across mode changes In these observed workflows, Jack's clearest advantage was not raw syntax generation. It was **control over the reasoning process**: - reconstructing authoritative state - finding weaknesses in another model's work - inspecting the tests as evidence rather than merely accepting them - preserving constraints into execution - separating observation from assumption - maintaining configuration boundaries - returning to deep reasoning when review warranted it These are controlled demonstrations, not proof that Jack universally outperforms the compared models on all tasks. Community replication and broader evaluation are encouraged. --- # Research Preview / Experimental Model Jack 3.8 is a research-oriented model. It is intended to produce real work, but the architecture is also an active research program. Jack remains probabilistic. It can: - make reasoning errors - generate false-positive audit hypotheses - misinterpret ambiguous requirements - preserve an incorrect conclusion if that conclusion was incorrectly established upstream - fail to retrieve relevant history - over- or under-calibrate uncertainty - fail when an appropriate deterministic verifier is unavailable The architecture is designed to reduce important classes of long-horizon failure. It does not make them impossible. --- # Recommended Runtime Behavior For the intended Jack behavior: - use the model's embedded chat template - do not add a competing external system prompt unless intentionally testing interaction effects - preserve the conversation history - expose deterministic tools when available - allow Jack to use those tools when exact verification is appropriate - use native thinking selectively according to workflow requirements - keep Jack XML active in both thinking-ON and thinking-OFF operation - use a runtime capable of maintaining long context and tool history For LM Studio testing, use a fresh chat with the external **System Prompt empty** so the embedded Jack template is not duplicated or overridden. --- # Thinking Mode Guidance ## Thinking ON Best suited for: - initial architecture - novel planning - difficult debugging - ambiguous requirements - independent review - high-risk changes - adversarial audit - uncertainty - hypothesis generation - complex causal reasoning Expected behavior: > **Search broadly. Falsify aggressively. Calibrate before commitment.** ## Thinking OFF Best suited for: - execution of an established plan - repetitive edits - straightforward implementation - routine continuation - tool-oriented steps - actions whose governing constraints are already known Jack XML remains active. Thinking OFF is not "unaligned base-model mode." It is reduced native deliberation under the same Jack attention-anchoring and operative-state architecture. --- # Usage ## LM Studio 1. Download: ```text Jack-3.8-27B-Coder-16GB-VRAM.gguf ``` 2. Load the model in LM Studio. 3. Start a fresh chat. 4. Leave the external **System Prompt blank**. 5. Select the desired context length based on available memory and runtime configuration. 6. Toggle native thinking according to the stage of the workflow when your runtime exposes that control. --- ## llama.cpp Example local server: ```bash llama-server \ -m Jack-3.8-27B-Coder-16GB-VRAM.gguf \ -c 32768 ``` Increase context according to your hardware, KV-cache configuration, and runtime limits. Example terminal use: ```bash llama-cli \ -m Jack-3.8-27B-Coder-16GB-VRAM.gguf \ -p "Review this implementation against the original requirements." ``` --- # Large-Context Validation Jack 3.8 has been exercised in large-context local testing, including a **120,000-token runtime context configuration**. That figure describes a tested runtime setting, not a guarantee that every 120K-token workload will have identical quality or memory behavior across different runtimes, GPUs, KV-cache settings, or prompts. The Jack research target is not merely maximum token count. It is maintaining **operative state** as the historical context becomes large. --- # Hardware Target Jack 3.8 is built for the practical **16GB VRAM GPU class**. The final model file is approximately in the 12GB-class range, leaving the remaining GPU-memory budget for runtime overhead and KV cache depending on context configuration. Actual memory use depends on: - runtime - GPU backend - context length - KV-cache type - offload settings - batching - flash-attention support - tool/runtime integration The model is intended for local consumer hardware rather than datacenter-only deployment. --- # Quantization The Jack 3.8 release uses a deliberately selected GGUF quantization chosen to preserve the native reasoning and coding capability needed by the Jack architecture while fitting the model into the practical 16GB VRAM class. The exact quantization configuration is intentionally not disclosed. Quantization is treated as part of the engineering of the release rather than as a packaging afterthought. A weak quantization can destroy capabilities that no prompt architecture can recover. Jack therefore depends on the interaction of: > **model substrate + quantization quality + Jack cognitive architecture** --- # What Jack Is Not Jack 3.8 is not: - a guarantee of perfect reasoning - proof that a 27B model universally outperforms larger models - a replacement for deterministic verification - a claim that long context automatically equals memory - a claim that native thinking should always be ON - a claim that native thinking should always be OFF - a claim that XML is merely a second chain of thought - direct mechanistic proof that a particular XML tag controls a specific neural activation - a claim that earlier Jack research components are all implemented unchanged in this release Jack is an inference-time cognitive control architecture integrated with a capable local coding model. --- # Model Identity | Field | Value | |---|---| | Model | `Jack-3.8-27B-Coder-16GB-VRAM` | | Author | Jonathan Michael Langford — Independent Researcher, Lead Architect, The Jack Project | | Contact | `mlangford75@protonmail.com` | | Project / Research | https://github.com/mlangford75-lgtm/mlangford75-lgtm | | GGUF | `Jack-3.8-27B-Coder-16GB-VRAM.gguf` | | Model class | 27B Qwen3.8-derived | | Primary specialization | Agentic coding and long-context software engineering | | Format | GGUF | | Target hardware | 16GB VRAM consumer GPU class | | Native reasoning | Preserved | | Adaptive thinking | Supported by workflow/runtime when exposed | | Jack XML | Active structured attention/state architecture | | Deterministic tools | Supported when exposed by runtime | | External system prompt | Leave blank for intended embedded-template behavior | | Validated local runtime | LM Studio Chat | | Large-context test setting | 120,000 tokens | | Exact quantization | Intentionally undisclosed | | Vision | Text-only release | --- # Core Design Principle > **The model is not being asked to become a different intelligence. It is being given an architecture for keeping the right intelligence operative at the right time.** For short isolated tasks, native model capability may be enough. For long-running agentic coding work, intelligence must survive: - changing state - repeated tool calls - superseded artifacts - corrections - uncertainty - counterfactual branches - review - execution - final commitment Jack is designed around that problem. --- # One-Line Description > **Jack-3.8-27B-Coder-16GB-VRAM is a 27B Qwen3.8-derived local coding model with the Jack long-context cognitive architecture: structured attention anchoring, frontier state rebinding, operative recall, adversarial falsification, configuration separation, deterministic verification, and adaptive native reasoning for agentic software engineering on 16GB GPUs.** --- # Research Direction Jack asks a practical question: > **How much effective agentic intelligence can be recovered from local hardware by organizing cognition better rather than relying only on more parameters, more context, or permanently enabled deliberation?** That is the research program. Special Acknowledgement to https://empero.org