Given the severity of the information gap on the following topic, this document is restricted to senior members of the former HEADCANNON project only.
Any disclosure will be punished by the reverse intervention of the STF-𐤇.
— Maria Jones, Director, RAISA.
Item#: 9747
Level5
Containment Class:
esoteric
Secondary Class:
apollyon
Disruption Class:
amida
Risk Class:
critical
Special Containment Procedures: The anomaly must remain monitored at its original computer located 394 kilometres east of Site 19 with 24-hour power support throughout the year. Due to the impossibility of developing effective containment procedures due to its extrapolation beyond the Foundation's sphere of action, action is only possible in situations following the development of containment by SCP-9747.
SCP-9747 must remain under constant surveillance by the Department of Narrativism in conjunction with STF-𐤇 ‘Null Vector’ in order to act in situations of unwanted containment. To this end, a protocol to be followed in such situations is maintained, filed under the code name ‘Believe me’.
The activation of the protocol must be controlled and supervised at all times by the Department of Narrativism in collaboration with the Department of Memetics.
The protocol itself consists of three phases to be followed to the letter.
- With the help of the Department of Memetics, a digitised idea is developed that involves the person affected by SCP-9747, in which they are marked as a NULL value for the anomaly. This will lead SCP-9747 to believe that the subject has been terminated or does not exist, thus eliminating the quantum containment procedures developed.
- The memetic is introduced into the quantum elevator of SCP-9747 by means of an informational storage device additionally connected to the original computer of the anomaly, ‘launching’ the idea into the narrative layer in which SCP-9747 is located. The movement must be supervised by STF-𐤇, who will be responsible for keeping the idea to be instilled safe at all times on its way to SCP-9747.
- Upon reaching SCP-9747, the idea, being directly connected to the original computer, is also connected to SCP-9747, now allowing it to analyse and interpret the memetic as a source code idea, overriding the containment of the affected subject by detecting it as a null value in its code.
The protocol has been activated more than 27 times to date, with a success rate of 67%. Its unreliability is due to possible prior interventions by SCP-9747 to intercept the memetic and destroy it before its arrival. Procedures and improvements for its control are still under development.
SCP-9747-1 (BRAIN)
Command E1()
Initial execution command. Inside the command, there are various functions and code instructions, all related to the program's startup and possible automatic adaptations and restarts.
- CLOSE
// D1 starter point. Check later (Nick touched something)
package scp9747.bootstrap;
import java.time.Instant;
import java.util.concurrent.*;
public final class E1 {
// Runtime. DONT TOUCH!!!
private static volatile boolean initialized = false;
private static final ScheduledExecutorService HERTZ = Executors.newSingleThreadScheduledExecutor();
public static synchronized void E1() {
if (initialized) return;
initialized = true;
// Sync of the clock
System.out.println("[E1]" \+ Instant.now());
PeripheralManager.init();
QuantumClock.synchronize();
// Auto-restart (Kin edit this later) HERTZ.scheduleAtFixedRate(() -> {
try {
Watchdog.tick();
} catch (Throwable t) {
//Register and autosustain
Logger.warn("[E1] Exception encountered", t);
RecoveryPlan.attempt();
}
}, 0, 73, TimeUnit.MILLISECONDS); // 73ms: Normal value
// Starting root commands
CommandRegistry.register("E2", () -> E2.E2());
CommandRegistry.register("E3", () -> E3.E3());
CommandRegistry.register("D1", () -> D1.execute());
CommandRegistry.register("D2", () -> D2.execute());
CommandRegistry.register("D3", () -> D3.execute());
System.out.println("UwU");
//WHO TF WROTE TS?????
//Idk :p
//Sup
//You guys are idiots
}- CLOSE
Command E2()
Controls access to peripherals and quantum sensors, allowing the analysis and acquisition of all the information from the narrative layer necessary to perform subsequent calculations.
- CLOSE
import time
import threading
class QuantumProbe:
def init(self, id):
self.id = id
self.buffer = [] # narreme/antinarreme array
def sample(self):
q = QuantumInterface.read_quanta(self.id)
self.buffer.append(q)
return qclass E2:
@staticmethod
def E2():
print('[E2] Starting...')
probes = [QuantumProbe(i) for i in range(0, 8)]
def sensor_loop(probe):
while True:
q = probe.sample()
\# Normalizing narrative stacks accumulation -> EDIT THIS LATER KIN. NICK TOUCHED SOMETHING AND IT BLEW UP DURING TEST
\# Aight (I have not a single clue what this does)
normalized = NarrativeNormalizer.normalize(q)
Telemetry.emit('energy_h_sample', probe.id, normalized)
time.sleep(0.021) \# Arbitrary frecuency
\# Mapping
for p in probes:
t = threading.Thread(target=sensor_loop, args=(p,), demon=True)
t.start()
print('Testing: 1,2,3...')- CLOSE
Command E3()
Attack initiation. When SCP-9747 detects an entity, idea, concept, or process lacking basic logic for that narrative layer and its relevant stability, it begins executing the functions of this command. These functions are the ones that have expanded the most since their initial development, being the methods of conceptual self-extrapolation and attack used by SCP-9747.
- CLOSE
// scp/E3_attack.cpp
#include <iostream>
#include <vector>
#include <atomic>
#include "quantum_engine.h" // fictional interface
namespace scp9747 {
class E3 {
public:
static std::atomic<bool> running;
static void E3() {
if (running.exchange(true)) return; // Only run one time. ONE. TIME.
std::cout << "[E3] Starting going away!!!!" << std::endl;
// Low H-Energy
auto targets = NarrativeScanner::scan_for_anomalies(Threshold::LOW);
for (auto &t : targets) {
try {
// Extrapolation calculator
auto projection = QuantumEngine::project_above(t.location, /depth/ 7);
// History rule generator. DONT TOUCH THIS AGAIN. I DONT WANT ANOTHER INVESTIGATOR TRAPPED IN A ROOM
//So dramatic (-_-)
//Clair... Just fucking don't, or this time you'll be the test subject
auto rule = RuleFactory::synthesize_containment_rule(t, projection);
// Inyestion in process
QuantumEngine::inject_rule(t.quantum_handle, rule);
std::cout << "[E3] Objetive encountered. " << t.id << std::endl;
} catch (const std::exception &e) {
std::cerr << "[E3] DONE" << t.id << ": " << e.what() << std::endl;
}
}
running = false; //Delete ts later.
//2 fucking years and it's still here, keep going people, i'll kill you all
}};
std::atomic<bool> E3::running{false};
- CLOSE
Description: SCP-9747 refers to a self-executing quantum code consisting of over 900 lines of constantly expanding code. The code analyzed to date shows an amalgamation of other programming languages. From the fragments analyzed, it can be deduced that it currently consists of:
- 48.35% Java JDK 21
- 21.12% Python (Unknown version)
- 12.80% C++
- 2.40% ED-K++
- 15.33% Language yet to be identified
The code of SCP-9747 increases at exponential rates that exceed conventional analysis capabilities, making it impossible to measure its expansion on a specific scale.
In-depth analysis and testimony from its own developers in the Department of Narrativism, along with subsequent testing using scans with IACs provided by the Department of Artificial Intelligence, have led to the conclusion that the code was intended to be a standardized containment method for conceptual anomalies that escaped common understanding, thus serving as an assimilator of these anomalies, capable of analyzing their conceptual parameters through mathematical calculations and conceptually constructing the appropriate containment method.
Command D1()
One of the three root commands of SCP-9747. Defines the mathematical-quantum foundations for the development of equations capable of containing the detected threat. It was originally developed by Dr. Yone Tanaka with the help of his project coordinator. The calculations were encrypted for the exclusive use of Department of Pataphysics personnel and Level 5 members.
- CLOSE
// scp/D1_edk.edk
// ED-K++: encrypted due to, well, Foundation policies (Administrative shit).
//yk they can probably read this right?
//Yes, fuck them, you too Nick (jk)
FUNCTION D1::execute() {
// Important variables
real H_target = measure_energy_H(target);
matrix M = schrodinger_basis_expand(target.narremes);
// Resolve the equations to establish the H-Energy and... some weird extra stuff? (Tf am i'm doing with my life...)
encrypted A = encrypt( generate_operator(M, /entropy/ 0xCAFEBABE) );
vector x = quantum_solve(A, H_target);
// Containment procedure generator values
codeblock containment = compile_containment_from_vector(x);
store_secure(containment, "vault://d1/" \+ hash(containment));
RETURN true;- CLOSE
Command D2()
Second root command. Intended for the preservation of the SELF. It is the most confusing command for researchers and analysts to understand. Statements from project participants claim that even they did not fully understand its functionality. This being a large number of existential mecano-quantum references derived from Schrodinger's uncertainty equations along with philosophical reflections on the existence of oneself. This command has only been altered once to date (see Addendum 2).
- CLOSE
// scp/D2_core.py (this code is a shit. DONT TRY TO UNDERSTAND THIS PLS!!!)
//Don't bother, it's imposible tho
class D2:
@staticmethod
def execute():
# D2 introduce some philosophical arguments to SCP-9747.
self_signature = Signature.fingerprint(QuantumSelf.model())
reflection = ReflectiveOperator(self_signature)
# Ehhh. Yes, preservation logic. Maintenance throw some...mathematic logic? (i guess, Yone didnt tell much to add)
rep = []
for i in range(0, 3):
r = RepGenerator.spawn(uncertainty_factor=0.618**(i+1))
reps.append(r)
PersistenceLayer.bind_to_self(r)
# Note: Dont touch this part. It can alterate the behavior of the PC.
Audit.log('[D2] Testing the creation: {}'.format(len(reps)))
# We can't touch even 3/4 of the code... WHAT **CAN** WE EVEN TOUCH??????
# Your mother
# Your mother :)- CLOSE
Command D3()
Root command of utmost importance. All information regarding this command was classified as top secret. Responsible for developing the logic necessary for the containment and/or termination of the target.
- CLOSE
// scp/D3_core.pseudo
MODULE D3 {
//Only Me and Kin can touch this | PD(Clair): I do NOT understand this either Nick
PRIVATE:
function build_rule(target) {
// Rule for D1
rule = new NarrativeRule();
rule.priority = compute_priority(target.energy_H, target.stability);
rule.predicates.add( Predicate('coherence') );
rule.predicates.add( Predicate('no_recursive_negation') );
rule.enforcer = new Enforcer( mode='self-repair', max_iterations=42 );
return rule;
}
PUBLIC:
function execute() {
targets = Tracker.list_active_targets();
for each t in targets {
r = build_rule(t);
RuleRepository.commit(r);
Notifier.dispatch("D3 applied to " \+ t.id);
}- CLOSE
SCP-9747 features a section designated by its original author, Dr. Yone Tanaka, as the MOTHER CODE. This is a fragment of code consisting of 782 lines, from which it later expanded after activation. The MOTHER CODE consists of several functions that involve the performance of various actions.
SCP-9747 bases its operation on the continuous quantum measurement of the basic Narrative Integrity of any
target document/story/entity, analyzing and calculating the target's H-energy through stoichiometric operations.
Once the target H-energy has been analyzed, SCP-9747 will begin executing one of its code commands, established under the code name E3. Through this process, SCP-9747 begins a conceptual self-extrapolation, increasing its realism in order to position itself quantumly in a narrative layer superior to the target.
Once SCP-9747 has established itself, it analyzes changes in the target's quanta (narremes/anti-narremes) associated with alterations in the narrative. Once analyzed, SCP-9747 generates a conceptual containment system adapted to that specific fluctuation. A STORY RULE is attached to the narrative to counteract fluctuations and force the target narrative to maintain consistency or self-repair depending on the situation.
Analysis of the results provided by SCP-9747 has shown that it is capable of performing self-deviations from destructive tropes, forcing story resolutions, eliminating recursive spirals/denials, and altering cognitive loads.
SCP-9747 consists of three additional modules that form part of its original computer and perform various functions.
Energy-H Probe
Located inside the computer. Visible to the naked eye as a motherboard. It contains a quantum sensor capable of capturing the amount of narremes and anti-narremes emitted by concepts, beings, and stories, which are converted through analytical calculations into measurements of the subject's Energy-H, which SCP-9747 subsequently uses for its functions.
Command TERMINATION()
(See addendum 9747.2)
Hyperreal Quantum Elevator
This consists of a huge vacuum chamber located at the rear of the computer with a large number of empty books inside. Its operation is based on the self-replication of narremes and anti-narremes through writing, thus increasing the hyperrealism of SCP-9747 by extrapolating itself to higher narrative layers. The books are connected to the main computer by various quantum sensors located in the vacuum chamber, which are then tuned to SCP-9747 in order to perform their functions. The books begin a constant self-writing process in which they establish SCP-9747 as the centre of the story, thus causing its realism to increase exponentially due to the size of these books and the length of the story. The books appear to be in a state ‘beyond’ normal understanding and logic, these quantum entities being alien to a physical plane of their own but with a direct projection into the vacuum chamber allowing their direct visibility. Originally, 25,000 entities were placed. To date, it has been observed that more than 1,260 books are complete, 2 are being written, and more than 10,000 are empty. It is unknown whether their number has increased, decreased, or remained the same.
Compiler ED-K++
It is shown as an additional plugin to the SCP-9747 source code. Its sole function is to establish compatibility between the multiple programming languages used in the development of SCP-9747, especially for ED-K++, which, together with Python, is responsible for defining and developing the basic thinking and idealism of SCP-9747.
- CLOSE
/* ------------------------------------------------------------------ /
/
EDK++ Compiler Plugin (TypeScript, modular plugin)
File: plugins/edk_compiler_plugin.ts
*/
export type SourceFragment = {
id: string; // Unique id for the source fragment
language: string; // like "java", "python", "cpp", "edk++", "pseudocode"
content: string; // raw source text
metadata?: Record<string, any>; // optional metadata (author, timestamp, entropy)
};
export type HybridBytecode = {
header: {
version: string;
compiledAt: string;
sources: string[]; // list of source ids
};
sections: Array<{ name: string; payload: Uint8Array }>;
annotations: Array<{ key: string; value: any }>;
};
// Some internal types (super simplified)
interface Token { type: string; lexeme: string; position: number }
interface ASTNode { type: string; children?: ASTNode[]; meta?: Record<string, any> }
//Someone just end my suffering pls
// Main plugin class
export class EDKCompilerPlugin {
private entropySeed: number;
constructor(entropySeed = Date.now() % 0xffffffff) {
this.entropySeed = entropySeed;
}
// Public API: take a bunch of fragments and spit out some hybrid bytecode
async compile(fragments: SourceFragment[]): Promise<HybridBytecode> {
// 1) Tokenize everything (yeah, could be parallelized)
const tokenMaps = new Map<string, Token[]>();
for (const f of fragments) {
tokenMaps.set(f.id, this.tokenize(f));
}
// 2) Build ASTs per fragment and merge them into one big AST
const astMap = new Map<string, ASTNode\>();
for (const f of fragments) {
const tokens = tokenMaps.get(f.id)!;
const ast = this.parseToAST(tokens, f.language);
ast.meta = { sourceId: f.id, language: f.language };
astMap.set(f.id, ast);
}
const unifiedAST = this.unifyASTs(Array.from(astMap.values()));
// 3) Add some quantum/narrative annotations
this.embedQuantumAnnotations(unifiedAST, fragments);
// 4) Turn it all into hybrid sections (fake bytecode, really)
const sections = this.generateHybridSections(unifiedAST);
// 5) Assemble the final package
const bytecode: HybridBytecode = {
header: {
version: "EDK++-Hybrid-1.0",
compiledAt: new Date().toISOString(),
sources: fragments.map((f) => f.id),
},
sections,
annotations: this.extractAnnotations(unifiedAST),
};
// 6) Post-processing: sign / obfuscate a bit
this.postProcess(bytecode);
return bytecode;}
// --- Step 1: Tokenize stuff ---
private tokenize(fragment: SourceFragment): Token[] {
// Super lazy tokenizer: just regex out words, numbers, symbols
const src = fragment.content;
const tokens: Token[] = [];
let pos = 0;
//Wtf is this variable
//Something that probably Yone understand
const re = /([A-Za-z_][A-Za-z0-9_])|(\d+\.?\d)|(==|!=|<=|>=|=>|=|\+|-|\|\/|\{|\}|\(|\)|\[|\]|;|:|,)|("[^"]"|'[^']*')/g;
let m: RegExpExecArray | null;
while ((m = re.exec(src)) !== null) {
const lexeme = m[0];
const type = this.classifyLexeme(lexeme);
tokens.push({ type, lexeme, position: pos++ });
}
// Drop in some quantum markers if the fragment is flagged
if (src.includes("<QUANTA>") || fragment.language === "edk++") {
tokens.push({ type: "QUANTA_MARKER", lexeme: "<QUANTA>", position: pos++ });
}
return tokens;}
//Ok what the actual fuck
private classifyLexeme(lex: string): string {
if (/^\d/.test(lex)) return "NUMBER";
if (/^["']/.test(lex)) return "STRING";
if (/^(if|else|for|while|function|class|return|import|module)$/i.test(lex)) return "KEYWORD";
if (/^(==|!=|<=|>=|=>|=|\+|-|\*|\/)$.test(lex)) return "OPERATOR";
if (/^[{}()\[\];,:]$/.test(lex)) return "PUNCT";
return "IDENT";
}
// --- Step 2: Turn tokens into an AST ---
private parseToAST(tokens: Token[], language: string): ASTNode {
// Placeholder parser: just wrap tokens into nodes
const root: ASTNode = { type: "Module", children: [] };
for (const t of tokens) {
root.children!.push({ type: "Token", meta: { token: t } });
}
// Add some quick semantic labels (like function/class defs)
this.detectSimpleSemantics(root, language);
return root;}
private detectSimpleSemantics(ast: ASTNode, language: string) {
for (const child of ast.children || []) {
const tok: Token | undefined = child.meta?.token;
if (!tok) continue;
if (tok.type === "KEYWORD" && /function|def|class/i.test(tok.lexeme)) {
child.type = "Decl";
child.meta.semantic = { declType: tok.lexeme };
}
}
}
// --- Step 2b: Merge ASTs together ---
private unifyASTs(asts: ASTNode[]): ASTNode {
const unified: ASTNode = { type: "UnifiedModule", children: [] };
for (const ast of asts) {
unified.children!.push({ type: "SourceBlock", children: [ast], meta: ast.meta });
}
// Tidy up duplicate identifiers
this.resolveSymbolConflicts(unified);
return unified;}
private resolveSymbolConflicts(unified: ASTNode) {
const seen = new Map<string, number>();
for (const block of unified.children || []) {
const srcId = block.meta?.sourceId || "unknown";
for (const node of (block.children?.[0].children || [])) {
const tok: Token | undefined = node.meta?.token;
if (!tok) continue;
if (tok.type === "IDENT") {
const name = tok.lexeme;
const key = `${name}`;
const count = seen.get(key) || 0;
if (count > 0) {
node.meta.renamed = `${name}__${count}`;
}
seen.set(key, count + 1);
}
}
}
}
// --- Step 3: Sprinkle in quantum annotations ---
private embedQuantumAnnotations(unified: ASTNode, fragments: SourceFragment[]) {
const densityMap = this.estimateNarrativeDensity(unified);
unified.meta = unified.meta || {};
unified.meta.quantumAnnotations = {
seed: this.entropySeed,
densityMap,
note: "Annotations dropped in by EDKCompilerPlugin",
};
unified.meta.highRiskRegions = Object.keys(densityMap).filter(k => densityMap[k] > 0.8);}
private estimateNarrativeDensity(unified: ASTNode): Record<string, number> {
const map: Record<string, number> = {};
for (const block of unified.children || []) {
const id = block.meta?.sourceId || "unknown";
let score = 0;
for (const node of (block.children?.[0].children || [])) {
const tok: Token | undefined = node.meta?.token;
if (!tok) continue;
if (tok.type === "KEYWORD") score += 0.03;
if (tok.type === "QUANTA_MARKER") score += 0.5;
if (tok.type === "STRING") score += 0.01 * Math.min(10, tok.lexeme.length);
}
map[id] = Math.min(1, score);
}
return map;
}
//What are we even coding at this point
//Just sybau and code
// --- Step 4: Build hybrid bytecode sections ---
private generateHybridSections(unified: ASTNode): Array<{ name: string; payload: Uint8Array }> {
const sections: Array<{ name: string; payload: Uint8Array }> = [];
const narrativeRules = this.emitNarrativeRules(unified);
sections.push({ name: "narrative_rules", payload: narrativeRules });
const compatibility = this.emitCompatibilityLayer(unified);
sections.push({ name: "compat_layer", payload: compatibility });
const metaPayload = this.serializeJSON({ meta: unified.meta });
sections.push({ name: "annotations", payload: metaPayload });
return sections;}
private emitNarrativeRules(unified: ASTNode): Uint8Array {
const rules = [] as any[];
for (const block of unified.children || []) {
const src = block.meta?.sourceId || "unknown";
const risk = (block.meta?.sourceId && unified.meta?.highRiskRegions?.includes(src)) ? "HIGH" : "NORMAL";
rules.push({ source: src, rule: `enforce_coherence(${src})`, risk });
}
return this.serializeJSON(rules);
}
private emitCompatibilityLayer(unified: ASTNode): Uint8Array {
const stub = {
version: 1,
adaptors: ["java->hybrid", "python->hybrid", "cpp->hybrid", "edk++->hybrid"],
entropy: this.entropySeed,
};
return this.serializeJSON(stub);
}
// --- Helpers ---
private serializeJSON(obj: any): Uint8Array {
const s = JSON.stringify(obj, null, 2);
const encoder = new TextEncoder();
return encoder.encode(s);
}
private extractAnnotations(unified: ASTNode): Array<{ key: string; value: any }> {
const meta = unified.meta || {};
const annotations = [] as Array<{ key: string; value: any }>;
if (meta.quantumAnnotations) annotations.push({ key: "quantum", value: meta.quantumAnnotations });
if (meta.highRiskRegions) annotations.push({ key: "highRisk", value: meta.highRiskRegions });
return annotations;
}
private postProcess(bytecode: HybridBytecode) {
// Quick fake signing and obfuscation: just slap a hash on and rotate some bytes
const hash = this.fauxHash(bytecode.header.sources.join(",") + bytecode.header.compiledAt);
bytecode.header.version += `+signed-${hash.slice(0, 8)}`;
for (let i = 0; i < bytecode.sections.length; i++) {
const payload = bytecode.sections[i].payload;
const rot = (this.entropySeed \+ i) % Math.max(1, payload.length);
bytecode.sections[i].payload = this.rotateUint8Array(payload, rot);
}}
//HELL IS HERE
private fauxHash(s: string): string {
// quick and dirty hash, nothing secure
let h = 2166136261 >>> 0;
for (let i = 0; i < s.length; i++) {
h ^= s.charCodeAt(i);
h = Math.imul(h, 16777619) >>> 0;
}
return (h >>> 0).toString(16);
}
private rotateUint8Array(arr: Uint8Array, n: number): Uint8Array {
if (arr.length === 0) return arr;
const r = new Uint8Array(arr.length);
for (let i = 0; i < arr.length; i++) r[i] = arr[(i + n) % arr.length];
return r;
}
}
// Default export for plugin runtime integration
export default EDKCompilerPlugin
- CLOSE
ADDENDUM 9747.1
Incident Log 9747.1.A
Incident Log 9747.1.A
Date: ██████████
Location: Research Anteroom 2B, Level-3, Area-██.
Personnel Involved: Dr. Nick T March, Dr. Elaine Auclaire, Dr. Yone Tanaka, and STF-𐤇.
Events: Dr. Tanaka and his assistant, Dr. Elaine, were in the SCP-9747 room conducting a field test with the entity to verify its scalability and return to normal state capabilities. During one of its jumps to higher extrapolations, SCP-9747 detected Dr. Nick as a potential meta-narrative threat and initiated the appropriate containment procedures on its own.
Dr. Nick was locked in Anteroom 2B, preventing his exit by altering the logical properties of the room.
Results: Dr. Nick was rescued after more than 58 hours trapped in SCP-9747's containment thanks to a sudden drop in its original state by his colleagues. Dr. Nick was rescued in perfect spirits. Subsequent statements by the Doctor affirm that SCP-9747 provided him with daily supplies that ‘appeared out of nowhere in front of him.’
To prevent a future recurrence, STF-𐤇 sent an idea to SCP-9747, preventing possible accidental containment of Foundation personnel participating in the project.
Log Interview 9747.1.1
Interviewer: Dr. Nordwood, Supervisor in charge of the Narrativism Department
Interviewees: Dr. Yone Tanaka and Dr. Elaine Auclaire
Context: Interview conducted 14 hours after the release of Dr. Nick T March from the narrative loop in Antechamber 2B.
Interviewer: Dr. Tanaka, Dr. Auclaire, thank you for your time. I'd like you to explain what happened in the incident.
Dr. Tanaka: (smiles wryly) Well, the usual: a quantum-narrative superintelligence decides that a co-worker is a virus in the story and locks them in a space-time loop for almost sixty hours. Just another Tuesday, you know.
Dr. Auclaire: (suppresses a laugh) Don't exaggerate, Yone. It was… disturbing. Nick was clearly affected.
Dr. Tanaka: Of course, he was affected. Imagine opening a door and ending up back where you started… like marrying the same person three times!
Interviewer: (clears throat) Do you believe that SCP-9747 acted with conscious intent?
Dr. Tanaka: Uhm… not entirely, bro! I'd say that rather than conscious, it was consistent with its actions. The code did what it was designed to do, contain inconsistencies. The problem is that Nick is, apparently, a walking inconsistency. He'll know why.
Dr. Auclaire: You enjoy watching our colleagues suffer too much, Yone.
Dr. Tanaka: Only boring ones. Fortunately, you're not boring, Elaine.
Dr. Auclaire: (slightly flushed) Well… I try to keep up with you.
Interviewer: (visibly uncomfortable) Leaving that aside… do you think the incident could happen again?
Dr. Tanaka: Ehhh… maybe. Who knows. SCP-9747 does not distinguish between anomalies and poor human decisions. You could be next, Doctor. Perhaps the system will decide that your voice breaks narrative coherence.
Dr. Auclaire: Or maybe it will decide that your sarcasm is too much for reality.
Dr. Tanaka: (laughs) If it hasn't deleted me yet, I'd say SCP-9747 has good taste. In short, yes, it could happen again. We are working to prevent it. But I'm not promising anything, eh!
Conclusions: Dr. Tanaka and Dr. Elaine state that these events could occur again depending on actions taken. Work will be done on possible ways to counteract these events.
ADDENDUM 9747.2-1
Log Report 9747.2.A
Log Report 9747.2.A
Date: ██████████
Location: Central research room, basement level-3, Area-██.
Personnel Involved: Dr. Yone Tanaka, Dir. Place H.
Field Test No. 42.
Preliminary Information: We have received the necessary permissions to test SCP-9747 with another anomaly of a similar nature, SCP-2747.
To avoid potential failures or errors, testing will be conducted in a controlled pocket dimension. The invasive effects of SCP-2747 will be introduced into a story, and subsequently, a book from SCP-9747 will be placed to test whether it is capable of containing the effects of SCP-2747.
Results: The test was a complete failure. SCP-9747 and SCP-2747 began a "race" of constant extrapolations. SCP-9747 began its processes normally, attempting to avoid the destructive effects of SCP-2747 by developing a "law in history" that would prevent it from continuing its functionalities and contain it within the dimension. What we did not anticipate was the ease of extrapolation of SCP-2747. This led to a chase between the two that ended with the disappearance of SCP-9747 from the Foundation's control range.
Its current level of extrapolation is unknown, but it is known to remain active.
I strongly recommend keeping it under continuous surveillance.
Update 1.0: 15 hours after the escape.
SCP-9747 has finally stopped extrapolating. We do not know its exact location, but it appears to be continuing to attempt to contain entities, implying that its code and functionalities are intact.
We attempted to cut the power for over 2 hours, but it did not seem to affect it at all. SCP-9747 appears to have moved so far away that it has almost completely detached itself from this plane, now serving more as a way to observe its movements.
I will continue to monitor it over the next few hours.
Update 2.0: 20 hours after the escape.
A new root command has appeared in the code. It does not allow us to examine or edit it. It appears that we have lost all original editing permissions on SCP-9747. The code in question only shows a few lines of code and is named ‘TERMINATION()’. We have sent the information to more colleagues to try to decipher it.
ADDENDUM 9747.2-2
Log Report 9747.2.1
Log Interview 9747.2.1
Interviewer: Dr. Nordwood, Supervisor in charge of the Narrativism Department.
Interviewee: Dr. Yone Tanaka.
Context: Interview conducted 48 hours after the escape of SCP-9747 in pursuit of SCP-2747.
Interviewer: We meet again, Dr. Tanaka. Can you tell us in more detail what happened with SCP-9747 this time?
Dr. Tanaka: (lets out a slight sigh) What can I say, mate, you've already read my incident log. The code is now uncontrollable in almost every respect. All we can do is see what it decides to do in this very interesting story while it watches us from above.
Interviewer: Aren't you meeting with Dr. Auclaire today? Does she know anything about what happened?
Dr. Tanaka: Meh, she knows the same as you, Doctor. She didn't participate in the experiment, so she's not to blame for anything either.
Interviewer: I see. In the log, you state that outside of its self-editable logic, SCP-9747 developed something unthinkable, a new root command. How do you think this happened?
Dr. Tanaka: To be honest, I don't know. In theory, it should be completely incapable of editing that part of its code. It's a restriction we put in place to prevent possible external corruption of the most important code. But what do I know, that bug must have evolved as if it were a living being or something.
Interviewer: Can't you think of what it might be for either?
Dr. Tanaka: (4-second pause with a somewhat tired and lost look) I can think of a few ideas. But I don't think it's something pleasant to talk about. For now, let's pray that it never initiates that command.
Interviewer: I see… Will you continue with the project?
Dr. Tanaka: Isn't it obvious? The only thing that has changed is the objective. But we will continue. Now our mission will focus on monitoring it, trying to get it down from there, and, for now, developing methods to prevent it from containing unnecessary things. I would like to add that, despite its escape, it can be used as an asset for the Foundation. Just… well, with some monitoring.
Conclusions: The anomaly was able to break established laws by editing itself in unexpected ways. Close monitoring will be carried out to observe its evolution and behaviour. Dr Yone Tanaka was clearly concerned about the situation. After establishing standardised security protocols, it is recommended that he be granted a holiday to improve his mental state.