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
1PLAN_V1 = rejected
2PLAN_V2 = authoritative
and still fail if PLAN_V1 continues to influence execution.
It may remember:
text
1CONFIG_A = measured
2CONFIG_B = untested
and still fail if the result from A is silently transferred to B.
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
1LONG CONTEXT / NATIVE REASONING
2────────────────────────────────────────────
3old state
4new state
5hypotheses
6rejected branches
7calculations
8tool results
9counterfactuals
10corrections
11more reasoning
12more reasoning
13more reasoning
14 │
15 ▼
16JACK XML REBINDING
17────────────────────────────────────────────
18<workspace_state> operative state
19<grounded_source> evidence that controls the conclusion
20<anchor_fact> exact critical variables and identities
21<deterministic_check> verified external results when applicable
22<pitfall_check> active falsification / failure boundaries
23 │
24 ▼
25FINAL 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
<workspace_state>
<workspace_state> 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.
<grounded_source>
<grounded_source> rebinds the evidence that should govern the answer.
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.
<pitfall_check>
<pitfall_check> 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
1PLAN / NOVEL PROBLEM
2Native thinking: ON
3Jack XML: ACTIVE
4 │
5 ▼
6expansive planning, search, falsification
78ROUTINE EXECUTION
9Native thinking: OFF
10Jack XML: ACTIVE
11 │
12 ▼
13aligned execution under anchored state
1415NEW FAILURE / UNCERTAINTY
16Native thinking: ON
17Jack XML: ACTIVE
18 │
19 ▼
20deep debugging and hypothesis search
2122CONTINUED EXECUTION
23Native thinking: OFF
24Jack XML: ACTIVE
25 │
26 ▼
27efficient implementation
2829INDEPENDENT REVIEW
30Native thinking: ON
31Jack XML: ACTIVE
32 │
33 ▼
34adversarial 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 <pitfall_check>, re-evaluated the authoritative rollback rules, explicitly marked the earlier anchor as wrong, and repaired the state before final commitment.
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
1requirement
2→ plan
3→ implementation
4→ failure
5→ diagnosis
6→ revised plan
7→ new artifact
8→ test
9→ external review
10→ correction
11→ 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:
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
1PLANNING
2Native thinking: ON
3 ↓
4Jack reconstructs and anchors the authoritative plan
56EXECUTION
7Native thinking: OFF
8 ↓
9Jack carries out the established plan under active XML alignment
1011REVIEW
12Native thinking: ON
13 ↓
14Jack 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
1model hypothesis
2 ↓
3deterministic check
4 ↓
5verified result
6 ↓
7Jack rebinds verified result into operative state
8 ↓
9later 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.
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
Increase context according to your hardware, KV-cache configuration, and runtime limits.
Example terminal use:
bash
1llama-cli \2 -m Jack-3.8-27B-Coder-16GB-VRAM.gguf \3 -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
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?
